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 1b5bff892..166c609e9 100644
--- a/Benchmarks/RecursionDebug.lean
+++ b/Benchmarks/RecursionDebug.lean
@@ -101,19 +101,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"
@@ -125,6 +130,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 4bdd9e125..6cf8abb33 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
@@ -542,8 +658,17 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
               aiurSystem.prove funIdx witness.input witness.inputIOBuffer
             else
               aiurSystem.proveIxVM funIdx witness.input witness.inputIOBuffer
-          (.ok (claim, proof, ioBuf) :
-            Except String (Array Aiur.G × Aiur.Proof × Aiur.IOBuffer))
+          (.ok (claim, proof, ioBuf, none) : Except String
+            (Array Aiur.G × Aiur.Proof × Aiur.IOBuffer × 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
@@ -555,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
@@ -592,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}"
@@ -624,8 +758,8 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
             (← IO.getStdout).flush
             TracingTexray.resetPeakTreeRss
             let ((rvClaim, rvProof), rvProveSec) ← timed fun _ =>
-              vSystem.proveMultiStark vIdx pubInput proofBytes vkBytes
-                claimBytes useInterp
+              vSystem.proveMultiStark vIdx pubInput adviceBytes vkBytes
+                innerClaimsBytes useInterp
             let rvPeak ← TracingTexray.peakTreeRssBytes
             let rvProofBytes := Aiur.Proof.toBytes rvProof
             let (rvVerifyRes, rvVerifySec) ← timed fun _ =>
@@ -644,13 +778,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;
@@ -660,12 +935,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 eebdffbbc..581bc3ce1 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,9 +2104,10 @@ dependencies = [
 [[package]]
 name = "multi-stark"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=c72d32130eb084327b73849e39c92734a8829011#c72d32130eb084327b73849e39c92734a8829011"
+source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=249b74053c9dac775c5954af7d01fd3dae9d98ed#249b74053c9dac775c5954af7d01fd3dae9d98ed"
 dependencies = [
  "bincode",
+ "num-bigint 0.5.1",
  "p3-air",
  "p3-blake3",
  "p3-challenger",
@@ -2369,6 +2390,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"
@@ -2504,18 +2535,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",
@@ -2524,12 +2556,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",
@@ -2537,40 +2568,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",
@@ -2581,32 +2610,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",
@@ -2617,23 +2645,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",
@@ -2642,10 +2660,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",
@@ -2656,16 +2674,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",
@@ -2676,10 +2694,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",
@@ -2688,47 +2706,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",
@@ -2737,12 +2749,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",
@@ -2750,11 +2774,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]]
@@ -3156,6 +3180,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",
 ]
@@ -3612,6 +3637,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",
 ]
@@ -3645,12 +3676,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"
@@ -4062,16 +4087,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 f535dd771..8d5288835 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 = "c72d32130eb084327b73849e39c92734a8829011" }
+multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "249b74053c9dac775c5954af7d01fd3dae9d98ed" }
 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 57f954a8c..54de01169 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)
   let r := proveIxVM' system funIdx args ioBuffer.data.toArray ioBuffer.map.toArray
   (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,44 @@ 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) :
     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)
+
 @[extern "rs_aiur_system_prove_addr_with_env"]
 private opaque proveAddrWithEnv' : @& AiurSystem →
   @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool →
@@ -189,6 +231,13 @@ def shardProveWithEnv (system : @& AiurSystem)
 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
 
 namespace Bytecode.Toplevel
diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean
index e699b165a..36ec47317 100644
--- a/Ix/Aiur/Semantics/BytecodeFfi.lean
+++ b/Ix/Aiur/Semantics/BytecodeFfi.lean
@@ -160,6 +160,8 @@ def executeIxVM (toplevel : @& Bytecode.Toplevel)
     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 +173,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
diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean
new file mode 100644
index 000000000..85e0076ce
--- /dev/null
+++ b/Ix/Cli/AggregateCmd.lean
@@ -0,0 +1,1043 @@
+/-
+  `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 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 }
+
+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
+
+/-- 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]
+    }
+
+/-- 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. -/
+def runAggregateCmdWith (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 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
+
+  -- Reconstruct every shard statement/tree from the environment once. This
+  -- both binds proof wrappers to shard ids and supplies canonical join advice.
+  let mut prepared : Array PreparedShard := #[]
+  let mut digestToShard : Std.HashMap Address Nat := {}
+  for (blocks, shard) in view.shards.mapIdx fun shard blocks => (blocks, shard) do
+    let originalShard := (view.shardIds[shard]?).getD shard
+    let item ← match prepareShard env blocks with
+      | .error e => IO.eprintln s!"prepare shard {originalShard}: {e}"; return 1
+      | .ok item => pure item
+    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
+    prepared := prepared.push item
+
+  -- 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 proofsByShard : Std.HashMap Nat Ixon.Proof := {}
+  for proofHex in proofHexes do
+    let proofAddress ← match addrOfHex "shard proof" proofHex with
+      | .error e => IO.eprintln e; return 1
+      | .ok address => pure address
+    let wrapper ← match Ixon.Proof.de (← StoreIO.toIO (Store.read proofAddress)) with
+      | .error e => IO.eprintln s!"decode shard proof {proofAddress}: {e}"; return 1
+      | .ok wrapper => pure 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 ixvmCompiled ← match ← compileToplevel "IxVM" IxVM.ixVM with
+    | .error e => IO.eprintln e; return 1
+    | .ok compiled => pure compiled
+  let aggrCompiled ← match ← compileToplevel "ixAggr recursion" Aggr.ixAggr with
+    | .error e => IO.eprintln e; return 1
+    | .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
+    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 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
+
+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..0f7d52e8f 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", "_"),
@@ -418,6 +431,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 +454,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
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..57d16a582 100644
--- a/Ix/Cli/CheckCmd.lean
+++ b/Ix/Cli/CheckCmd.lean
@@ -428,34 +428,146 @@ 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
+  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. 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
+    if position != buffer.size then
+      throw s!"ixes: {buffer.size - position} trailing bytes after aggregation tree"
+    pure { shards, shardIds := Array.range n.toNat, aggregationTree := tree }
   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`). -/
@@ -482,11 +594,58 @@ def ownedConstsForBlocks (ixonEnv : Ixon.Env) (blocks : Array Address) : Array A
     if blockSet.contains (blockAddrOf addr c) then o := o.push addr
   return o
 
+/-- 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
+    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 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
+      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 }, 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
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/VerifyCmd.lean b/Ix/Cli/VerifyCmd.lean
index 8eb65094b..ccd089bd1 100644
--- a/Ix/Cli/VerifyCmd.lean
+++ b/Ix/Cli/VerifyCmd.lean
@@ -18,7 +18,10 @@ 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 section
@@ -50,7 +53,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 +86,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).
@@ -146,8 +252,59 @@ 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
@@ -164,6 +321,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 +333,10 @@ 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)."
 
   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/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/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/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/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..6bbac80b8 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›,
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..e17ab23a1
--- /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..1e6c5a24d
--- /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..ec22f08eb
--- /dev/null
+++ b/Tests/AggrSemantics.lean
@@ -0,0 +1,586 @@
+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, _) := selfSystem.prove fakeAggrIdx
+    (Aggr.pubInput allowed leftBytes) default
+  let (_, rightProof, _) := selfSystem.prove fakeAggrIdx
+    (Aggr.pubInput allowed rightBytes) default
+  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 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 (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 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, _) := scheduledSystem.prove fakeAggrIdx
+      (Aggr.pubInput scheduledAllowed claimBytes) default
+    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 "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 "two-shard manifest passes exact environment coverage" pairCoverage,
+    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/Main.lean b/Tests/Main.lean
index 6e9b547ce..8a33983c6 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -53,6 +53,9 @@ 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.ShardMap
 import Tests.Ix.EnvBody
@@ -184,6 +187,10 @@ 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),
 ]
 
 /-- Ignored test runners - expensive, deferred IO actions run only when explicitly requested -/
@@ -317,6 +324,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 a1b09e149..ebea33c90 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
 
 /-!
@@ -155,7 +161,11 @@ def endToEndSuite : IO UInt32 := do
   let input := #[Aiur.G.ofNat 5]
   let (claim, proof, _) := facSystem.prove facIdx input default
   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
@@ -199,7 +209,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 :=
@@ -226,6 +238,895 @@ 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
+    let (outerClaim, proof, _) := childSystem.prove liftIdx liftInput default
+    (fakeIxvmVk, innerClaimsBytes, outerClaim, proof)
+  let (fakeIxvmVk, leftInnerClaims, leftOuter, leftProof) := mkLift leftClaimBytes
+  let (_, rightInnerClaims, rightOuter, rightProof) := mkLift rightClaimBytes
+  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, _) :=
+    childSystem.prove childJoinIdx joinChildInput default
+  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, _) :=
+    childSystem.prove childJoinIdx wrongJoinChildInput default
+  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, _) :=
+    childSystem.prove childStructuralJoinIdx structuralChildInput default
+  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, _) := scheduledProofSystem.prove liftIdx liftInput default
+      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, _) := scheduledProofSystem.prove childJoinIdx pubInput default
+      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..96f81c08b 100644
--- a/crates/aiur/src/execute.rs
+++ b/crates/aiur/src/execute.rs
@@ -209,7 +209,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!(
@@ -1052,14 +1052,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/synthesis.rs b/crates/aiur/src/synthesis.rs
index 552743c28..cd4762b5a 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,
@@ -149,7 +149,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,
@@ -443,6 +447,24 @@ impl AiurSystem {
   ) -> Result<(), VerificationError<PcsError>> {
     self.system.verify(claim, proof)
   }
+
+  /// Re-encodes a verified proof into the per-query advice transport the
+  /// in-circuit verifier consumes (see `multi_stark::advice`): the pruned
+  /// FRI Merkle multiproofs expanded into one authentication path per
+  /// query. Fails if the proof does not verify natively.
+  pub fn proof_to_advice_bytes(
+    &self,
+    claim: &[G],
+    proof: &AiurProof,
+  ) -> Result<Vec<u8>, multi_stark::advice::AdviceError> {
+    multi_stark::advice::proof_to_advice_bytes(
+      &self.system,
+      self.commitment_parameters,
+      self.fri_parameters,
+      &[claim],
+      proof,
+    )
+  }
 }
 
 #[cfg(test)]
@@ -814,4 +836,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..d4db7b777 100644
--- a/crates/common/src/address.rs
+++ b/crates/common/src/address.rs
@@ -49,7 +49,9 @@ impl Address {
   /// bytes shorter than 32 are silently dropped (via `chunks_exact`).
   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/protocol.rs b/crates/ffi/src/aiur/protocol.rs
index acf20c60e..ede0b0445 100644
--- a/crates/ffi/src/aiur/protocol.rs
+++ b/crates/ffi/src/aiur/protocol.rs
@@ -59,6 +59,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 +164,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
@@ -400,7 +439,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(),
   )
@@ -683,7 +724,9 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch(
       }
       shards.push(
         bytes[off..off + n * 32]
-          .chunks_exact(32)
+          .as_chunks::<32>()
+          .0
+          .iter()
           .map(|c| ix_common::address::Address::from_slice(c).unwrap())
           .collect(),
       );
@@ -958,7 +1001,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:
@@ -1008,8 +1053,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)
+  } 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.
@@ -1050,6 +1193,228 @@ extern "C" fn rs_aiur_multi_stark_prove(
   result.into()
 }
 
+/// `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)
+  } 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..d2cfc88ff 100644
--- a/crates/ffi/src/kernel.rs
+++ b/crates/ffi/src/kernel.rs
@@ -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,
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..d9e1fcf63
--- /dev/null
+++ b/crates/ixvm-codegen/src/aiur_ix_aggr.rs
@@ -0,0 +1,25714 @@
+// 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 __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 = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __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_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_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)); };
+                        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)); };
+                        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)); };
+                    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)); };
+                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)); };
+            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)); };
+        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 __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 = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __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_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_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 __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)); };
+        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)); };
+        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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_2], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __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)); };
+        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_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 __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)); };
+        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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_3], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    match __v_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_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)); };
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __v_8: G = G::from_u64(0);
+                                    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)); };
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __v_8: G = G::from_u64(0);
+                                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)); };
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                          _ => {
+                            let __v_8: G = G::from_u64(0);
+                            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)); };
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        let __v_8: G = G::from_u64(0);
+                        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)); };
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_8: G = G::from_u64(0);
+                    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)); };
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_8: G = G::from_u64(0);
+                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)); };
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            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)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __v_8: G = G::from_u64(0);
+        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)); };
+        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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_4], ExecError> {
+  stacker::maybe_grow(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 __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_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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_5: usize = 12;
+const IN_5: usize = 12;
+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 __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_5] = [__v_12, __v_13, __v_14, __v_15];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+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_6], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __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_6] = [__v_8, __v_9, __v_10, __v_11];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_7: usize = 4;
+const IN_7: usize = 4;
+const OUT_7: usize = 4;
+fn aiur_fn_7(
+  inp: [G; IN_7],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_7], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __ret: [G; OUT_7] = [__v_2, __v_3, __v_0, __v_1];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_8: usize = 4;
+const IN_8: usize = 4;
+const OUT_8: usize = 4;
+fn aiur_fn_8(
+  inp: [G; IN_8],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_8], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __ret: [G; OUT_8] = [__v_1, __v_2, __v_3, __v_0];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_9: usize = 8;
+const IN_9: usize = 8;
+const OUT_9: usize = 4;
+fn aiur_fn_9(
+  inp: [G; IN_9],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_9], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __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_9] = [__v_16, __v_17, __v_18, __v_19];
+    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)); };
+    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 __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_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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_11: usize = 8;
+const IN_11: usize = 8;
+const OUT_11: usize = 8;
+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 __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_11] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+                                    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)); };
+                                    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_11] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
+                                    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)); };
+                                    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_11] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
+                                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)); };
+                                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_11] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
+                            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)); };
+                            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_11] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
+                        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)); };
+                        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_11] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
+                    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)); };
+                    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_11] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
+                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)); };
+                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_11] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+            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)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_0 + __v_8);
+        let __ret: [G; OUT_11] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+        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)); };
+        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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_12], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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_12] = [__v_26];
+    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)); };
+    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 __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_13] = [__v_28];
+    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)); };
+    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 __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_14] = [__v_22];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_15: usize = 1;
+const IN_15: usize = 1;
+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_15], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
+    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_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_16: usize = 1;
+const IN_16: usize = 1;
+const OUT_16: usize = 1;
+fn aiur_fn_16(
+  inp: [G; IN_16],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_16], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    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_16] = [__v_1];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_17: usize = 4;
+const IN_17: usize = 4;
+const OUT_17: usize = 2;
+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 __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_17] = [__v_4, __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)); };
+    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 __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 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)); };
+    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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_19], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(0);
+    let __v_3: G = (__v_2 - __v_0);
+    let __v_4: G = G::from_u64(0);
+    let __v_5: G = (__v_4 - __v_1);
+    let __ret: [G; OUT_19] = [__v_3, __v_5];
+    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)); };
+    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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_20], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = (__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_20] = [__v_8, __v_11];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_21: usize = 2;
+const IN_21: usize = 2;
+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 __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_21] = [__v_15, __v_18];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_22: usize = 4;
+const IN_22: usize = 4;
+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 __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_22] = [__v_25, __v_28];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_23: usize = 4;
+const IN_23: usize = 4;
+const OUT_23: usize = 1;
+fn aiur_fn_23(
+  inp: [G; IN_23],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_23], ExecError> {
+  stacker::maybe_grow(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 = (__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_23] = [__v_8];
+    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)); };
+    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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_24], 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() {
+      0u64 => {
+        let __ret: [G; OUT_24] = [__v_2, __v_3];
+        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)); };
+        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_24] = [__v_4, __v_7];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_25: usize = 1;
+const IN_25: usize = 1;
+const OUT_25: usize = 9;
+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 __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_24] = { let __args: [G; IN_24] = [__v_2]; 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_4]; 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__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 __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_8]; 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_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_10]; 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_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_12]; 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_13: G = __r_arr[0];
+    let __v_14: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_14]; 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_15: G = __r_arr[0];
+    let __v_16: G = __r_arr[1];
+    let __ret: [G; OUT_25] = [__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[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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_26: usize = 1;
+const IN_26: usize = 1;
+const OUT_26: usize = 2;
+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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; 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 __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_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __v_10: G = __r_arr[0];
+    let __ret: [G; OUT_26] = [__v_10, __v_9];
+    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)); };
+    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 __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_27] = [__v_2, __v_4];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_28: usize = 1;
+const IN_28: usize = 1;
+const OUT_28: usize = 9;
+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 __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_28] = [__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[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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_29: usize = 1;
+const IN_29: usize = 1;
+const OUT_29: usize = 2;
+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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+    let __v_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_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __v_10: G = __r_arr[0];
+    let __ret: [G; OUT_29] = [__v_10, __v_9];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_30: usize = 1;
+const IN_30: usize = 1;
+const OUT_30: usize = 3;
+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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+    let __v_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_28] = { let __args: [G; IN_28] = [__v_9]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+    let __v_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_30] = [__v_39, __v_60, __v_18];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_31: usize = 1;
+const IN_31: usize = 1;
+const OUT_31: usize = 33;
+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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+    let __v_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_28] = { let __args: [G; IN_28] = [__v_9]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+    let __v_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_28] = { let __args: [G; IN_28] = [__v_18]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+    let __v_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_28] = { let __args: [G; IN_28] = [__v_27]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+    let __v_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_31] = [__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[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)); };
+    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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_32], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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 __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)); };
+    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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_33], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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_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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; 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 { 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_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_33] = { let __args: [G; IN_33] = [__v_3, __v_5]; 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_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_33] = [__v_9, __v_7];
+        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)); };
+        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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_34], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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 __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)); };
+    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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_35], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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_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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __v_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_35] = { let __args: [G; IN_35] = [__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 __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_35] = [__v_16, __v_14];
+        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 = 1;
+const IN_36: usize = 1;
+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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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 __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)); };
+    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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_37], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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_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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __v_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_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __v_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_37] = { let __args: [G; IN_37] = [__v_19, __v_63]; 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 __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_37] = [__v_67, __v_65];
+        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)); };
+        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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_38], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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 __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)); };
+    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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_39], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __v_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_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __v_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_28] = { let __args: [G; IN_28] = [__v_19]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __v_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_28] = { let __args: [G; IN_28] = [__v_28]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __v_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_39] = { let __args: [G; IN_39] = [__v_37, __v_39]; 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_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_39] = [__v_44, __v_41];
+        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)); };
+        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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_40], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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 __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)); };
+    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_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_43], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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)); };
+        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 __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)); };
+        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_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_2, __v_1]; 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 = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_44] = [__v_3, __v_4];
+    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 = 2;
+const IN_45: usize = 2;
+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 __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_45] = [__v_4, __v_0];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0]; 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_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_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 __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_45] = [__v_9, __v_7];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_46: usize = 1;
+const IN_46: usize = 1;
+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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; 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 __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __ret: [G; OUT_46] = [__v_1, __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)); };
+    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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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; 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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_47] = [__v_3, __v_4];
+    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)); };
+    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 __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_48] = [__v_4, __v_0];
+        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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; 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 __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; 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 __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_48] = [__v_9, __v_7];
+        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);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_49: usize = 1;
+const IN_49: usize = 1;
+const OUT_49: usize = 4;
+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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; 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 __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]; 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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; 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 __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_49] = [__v_1, __v_3, __v_5, __v_6];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_50: usize = 1;
+const IN_50: usize = 1;
+const OUT_50: usize = 3;
+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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; 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 __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_50] = [__v_3, __v_5, __v_6];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_51: usize = 1;
+const IN_51: usize = 1;
+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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_2, __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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_51] = [__v_3, __v_4];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_52: usize = 2;
+const IN_52: usize = 2;
+const OUT_52: usize = 2;
+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 __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_52] = [__v_4, __v_0];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_3, __v_2]; 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_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_5]; 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 __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_52] = { let __args: [G; IN_52] = [__v_7, __v_9]; 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 __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_52] = [__v_13, __v_11];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_53: usize = 1;
+const IN_53: usize = 1;
+const OUT_53: usize = 4;
+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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; 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 { 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_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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; 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 __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_53] = [__v_1, __v_3, __v_5, __v_6];
+    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)); };
+    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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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; 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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_54] = [__v_3, __v_4];
+    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)); };
+    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 __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_55] = [__v_4, __v_0];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; 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 { 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_3]; 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 = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_5]; 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 __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; 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 __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_55] = [__v_13, __v_11];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_56: usize = 1;
+const IN_56: usize = 1;
+const OUT_56: usize = 3;
+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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_2, __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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_6, __v_5]; 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 __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __ret: [G; OUT_56] = [__v_3, __v_7, __v_8];
+    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)); };
+    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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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; 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_57] = [__v_3, __v_4];
+    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)); };
+    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 __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_58] = [__v_4, __v_0];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_3, __v_2]; 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 __v_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_7, __v_6]; 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 __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; 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_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_58] = [__v_15, __v_13];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_59: usize = 1;
+const IN_59: usize = 1;
+const OUT_59: usize = 13;
+fn aiur_fn_59(
+  inp: [G; IN_59],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_59], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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; 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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_4]; 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_8, __v_7]; 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_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10]; 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_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_12]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+    let __v_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_59] = [__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[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)); };
+    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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; 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 { 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];
+    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 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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2]; 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 __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 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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_61: usize = 1;
+const IN_61: usize = 1;
+const OUT_61: usize = 24;
+fn aiur_fn_61(
+  inp: [G; IN_61],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_61], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; 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 __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_6]; 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 __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_8]; 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 __v_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10]; 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_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __v_14: G = __r_arr[1];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_14, __v_13]; 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_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 = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_17: G = __r_arr[0];
+    let __v_18: G = __r_arr[1];
+    let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_18, __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 __v_19: G = __r_arr[0];
+    let __v_20: G = __r_arr[1];
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_20]; 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 = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_23: G = __r_arr[0];
+    let __v_24: G = __r_arr[1];
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_24, __v_23]; 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_25: G = __r_arr[0];
+    let __v_26: G = __r_arr[1];
+    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_26]; 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_27: G = __r_arr[0];
+    let __v_28: G = __r_arr[1];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_28]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+    let __v_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_44] = { let __args: [G; IN_44] = [__v_37]; 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 __v_38: G = __r_arr[0];
+    let __v_39: G = __r_arr[1];
+    let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_39]; 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 __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_44] = { let __args: [G; IN_44] = [__v_42]; 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 __v_43: G = __r_arr[0];
+    let __v_44: G = __r_arr[1];
+    let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_44]; 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 __v_45: G = __r_arr[0];
+    let __v_46: 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_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[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)); };
+    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 __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 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)); };
+    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 __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 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)); };
+    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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = G::from_u64(1);
+    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __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 __v_51: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__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 __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 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)); };
+    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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = G::from_u64(1);
+    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __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 __v_51: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_84];
+    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)); };
+    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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+    let __v_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 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)); };
+        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; 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 __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 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)); };
+            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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+            let __v_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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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 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)); };
+                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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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 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)); };
+                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 __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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+        let __v_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 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)); };
+            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; 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 __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; 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 __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 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)); };
+                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_67] = { let __args: [G; IN_67] = [__v_105]; 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 __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 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)); };
+                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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_7: G = __loaded[0];
+    let __v_8: G = __loaded[1];
+    let __v_9: G = __loaded[2];
+    match __v_7.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_10: G = __r_arr[0];
+        let __ret: [G; OUT_68] = [__v_10];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        match __v_2.as_canonical_u64() {
+          63u64 => {
+            let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; 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 __v_12: G = __r_arr[0];
+            let __ret: [G; OUT_68] = [__v_12];
+            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)); };
+            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; 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 __v_16: G = __r_arr[0];
+            let __ret: [G; OUT_68] = [__v_16];
+            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)); };
+            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 __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() {
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            match __v_7.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_10: G = __loaded[0];
+                let __v_11: G = __loaded[1];
+                let __v_12: G = __loaded[2];
+                match __v_10.as_canonical_u64() {
+                  0u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_13: G = __loaded[0];
+                    let __v_14: G = __loaded[1];
+                    let __v_15: G = __loaded[2];
+                    match __v_13.as_canonical_u64() {
+                      0u64 => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_16: G = __loaded[0];
+                        let __v_17: G = __loaded[1];
+                        let __v_18: G = __loaded[2];
+                        match __v_16.as_canonical_u64() {
+                          0u64 => {
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_19: G = __loaded[0];
+                            let __v_20: G = __loaded[1];
+                            let __v_21: G = __loaded[2];
+                            match __v_19.as_canonical_u64() {
+                              0u64 => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_22: G = __loaded[0];
+                                let __v_23: G = __loaded[1];
+                                let __v_24: G = __loaded[2];
+                                match __v_22.as_canonical_u64() {
+                                  0u64 => {
+                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                    let __v_25: G = __loaded[0];
+                                    let __v_26: G = __loaded[1];
+                                    let __v_27: G = __loaded[2];
+                                    match __v_25.as_canonical_u64() {
+                                      0u64 => {
+                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                        let __v_28: G = __loaded[0];
+                                        let __v_29: G = __loaded[1];
+                                        let __v_30: G = __loaded[2];
+                                        match __v_28.as_canonical_u64() {
+                                          0u64 => {
+                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                            let __v_31: G = __loaded[0];
+                                            let __v_32: G = __loaded[1];
+                                            let __v_33: G = __loaded[2];
+                                            match __v_31.as_canonical_u64() {
+                                              0u64 => {
+                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                let __v_34: G = __loaded[0];
+                                                let __v_35: G = __loaded[1];
+                                                let __v_36: G = __loaded[2];
+                                                match __v_34.as_canonical_u64() {
+                                                  0u64 => {
+                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                    let __v_37: G = __loaded[0];
+                                                    let __v_38: G = __loaded[1];
+                                                    let __v_39: G = __loaded[2];
+                                                    match __v_37.as_canonical_u64() {
+                                                      0u64 => {
+                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                        let __v_40: G = __loaded[0];
+                                                        let __v_41: G = __loaded[1];
+                                                        let __v_42: G = __loaded[2];
+                                                        match __v_40.as_canonical_u64() {
+                                                          0u64 => {
+                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                            let __v_43: G = __loaded[0];
+                                                            let __v_44: G = __loaded[1];
+                                                            let __v_45: G = __loaded[2];
+                                                            match __v_43.as_canonical_u64() {
+                                                              0u64 => {
+                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                let __v_46: G = __loaded[0];
+                                                                let __v_47: G = __loaded[1];
+                                                                let __v_48: G = __loaded[2];
+                                                                match __v_46.as_canonical_u64() {
+                                                                  0u64 => {
+                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                    let __v_49: G = __loaded[0];
+                                                                    let __v_50: G = __loaded[1];
+                                                                    let __v_51: G = __loaded[2];
+                                                                    match __v_49.as_canonical_u64() {
+                                                                      0u64 => {
+                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                        let __v_52: G = __loaded[0];
+                                                                        let __v_53: G = __loaded[1];
+                                                                        let __v_54: G = __loaded[2];
+                                                                        match __v_52.as_canonical_u64() {
+                                                                          0u64 => {
+                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                            let __v_55: G = __loaded[0];
+                                                                            let __v_56: G = __loaded[1];
+                                                                            let __v_57: G = __loaded[2];
+                                                                            match __v_55.as_canonical_u64() {
+                                                                              0u64 => {
+                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                let __v_58: G = __loaded[0];
+                                                                                let __v_59: G = __loaded[1];
+                                                                                let __v_60: G = __loaded[2];
+                                                                                match __v_58.as_canonical_u64() {
+                                                                                  0u64 => {
+                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                    let __v_61: G = __loaded[0];
+                                                                                    let __v_62: G = __loaded[1];
+                                                                                    let __v_63: G = __loaded[2];
+                                                                                    match __v_61.as_canonical_u64() {
+                                                                                      0u64 => {
+                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                        let __v_64: G = __loaded[0];
+                                                                                        let __v_65: G = __loaded[1];
+                                                                                        let __v_66: G = __loaded[2];
+                                                                                        match __v_64.as_canonical_u64() {
+                                                                                          0u64 => {
+                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                            let __v_67: G = __loaded[0];
+                                                                                            let __v_68: G = __loaded[1];
+                                                                                            let __v_69: G = __loaded[2];
+                                                                                            match __v_67.as_canonical_u64() {
+                                                                                              0u64 => {
+                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                let __v_70: G = __loaded[0];
+                                                                                                let __v_71: G = __loaded[1];
+                                                                                                let __v_72: G = __loaded[2];
+                                                                                                match __v_70.as_canonical_u64() {
+                                                                                                  0u64 => {
+                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                    let __v_73: G = __loaded[0];
+                                                                                                    let __v_74: G = __loaded[1];
+                                                                                                    let __v_75: G = __loaded[2];
+                                                                                                    match __v_73.as_canonical_u64() {
+                                                                                                      0u64 => {
+                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                        let __v_76: G = __loaded[0];
+                                                                                                        let __v_77: G = __loaded[1];
+                                                                                                        let __v_78: G = __loaded[2];
+                                                                                                        match __v_76.as_canonical_u64() {
+                                                                                                          0u64 => {
+                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                            let __v_79: G = __loaded[0];
+                                                                                                            let __v_80: G = __loaded[1];
+                                                                                                            let __v_81: G = __loaded[2];
+                                                                                                            match __v_79.as_canonical_u64() {
+                                                                                                              0u64 => {
+                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                let __v_82: G = __loaded[0];
+                                                                                                                let __v_83: G = __loaded[1];
+                                                                                                                let __v_84: G = __loaded[2];
+                                                                                                                match __v_82.as_canonical_u64() {
+                                                                                                                  0u64 => {
+                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                    let __v_85: G = __loaded[0];
+                                                                                                                    let __v_86: G = __loaded[1];
+                                                                                                                    let __v_87: G = __loaded[2];
+                                                                                                                    match __v_85.as_canonical_u64() {
+                                                                                                                      0u64 => {
+                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                        let __v_88: G = __loaded[0];
+                                                                                                                        let __v_89: G = __loaded[1];
+                                                                                                                        let __v_90: G = __loaded[2];
+                                                                                                                        match __v_88.as_canonical_u64() {
+                                                                                                                          0u64 => {
+                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                            let __v_91: G = __loaded[0];
+                                                                                                                            let __v_92: G = __loaded[1];
+                                                                                                                            let __v_93: G = __loaded[2];
+                                                                                                                            match __v_91.as_canonical_u64() {
+                                                                                                                              0u64 => {
+                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                let __v_94: G = __loaded[0];
+                                                                                                                                let __v_95: G = __loaded[1];
+                                                                                                                                let __v_96: G = __loaded[2];
+                                                                                                                                match __v_94.as_canonical_u64() {
+                                                                                                                                  0u64 => {
+                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                    let __v_97: G = __loaded[0];
+                                                                                                                                    let __v_98: G = __loaded[1];
+                                                                                                                                    let __v_99: G = __loaded[2];
+                                                                                                                                    match __v_97.as_canonical_u64() {
+                                                                                                                                      0u64 => {
+                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                        let __v_100: G = __loaded[0];
+                                                                                                                                        let __v_101: G = __loaded[1];
+                                                                                                                                        let __v_102: G = __loaded[2];
+                                                                                                                                        match __v_100.as_canonical_u64() {
+                                                                                                                                          0u64 => {
+                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                            let __v_103: G = __loaded[0];
+                                                                                                                                            let __v_104: G = __loaded[1];
+                                                                                                                                            let __v_105: G = __loaded[2];
+                                                                                                                                            match __v_103.as_canonical_u64() {
+                                                                                                                                              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() {
+                                                                                                                                                  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() {
+                                                                                                                                                          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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                            let __v_127: G = __loaded[0];
+                                                                                                                                                                            let __v_128: G = __loaded[1];
+                                                                                                                                                                            let __v_129: G = __loaded[2];
+                                                                                                                                                                            match __v_127.as_canonical_u64() {
+                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                let __v_130: G = __loaded[0];
+                                                                                                                                                                                let __v_131: G = __loaded[1];
+                                                                                                                                                                                let __v_132: G = __loaded[2];
+                                                                                                                                                                                match __v_130.as_canonical_u64() {
+                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                    let __v_133: G = __loaded[0];
+                                                                                                                                                                                    let __v_134: G = __loaded[1];
+                                                                                                                                                                                    let __v_135: G = __loaded[2];
+                                                                                                                                                                                    match __v_133.as_canonical_u64() {
+                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                        let __v_136: G = __loaded[0];
+                                                                                                                                                                                        let __v_137: G = __loaded[1];
+                                                                                                                                                                                        let __v_138: G = __loaded[2];
+                                                                                                                                                                                        match __v_136.as_canonical_u64() {
+                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                            let __v_139: G = __loaded[0];
+                                                                                                                                                                                            let __v_140: G = __loaded[1];
+                                                                                                                                                                                            let __v_141: G = __loaded[2];
+                                                                                                                                                                                            match __v_139.as_canonical_u64() {
+                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                let __v_142: G = __loaded[0];
+                                                                                                                                                                                                let __v_143: G = __loaded[1];
+                                                                                                                                                                                                let __v_144: G = __loaded[2];
+                                                                                                                                                                                                match __v_142.as_canonical_u64() {
+                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                    let __v_145: G = __loaded[0];
+                                                                                                                                                                                                    let __v_146: G = __loaded[1];
+                                                                                                                                                                                                    let __v_147: G = __loaded[2];
+                                                                                                                                                                                                    match __v_145.as_canonical_u64() {
+                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                        let __v_148: G = __loaded[0];
+                                                                                                                                                                                                        let __v_149: G = __loaded[1];
+                                                                                                                                                                                                        let __v_150: G = __loaded[2];
+                                                                                                                                                                                                        match __v_148.as_canonical_u64() {
+                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                            let __v_151: G = __loaded[0];
+                                                                                                                                                                                                            let __v_152: G = __loaded[1];
+                                                                                                                                                                                                            let __v_153: G = __loaded[2];
+                                                                                                                                                                                                            match __v_151.as_canonical_u64() {
+                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                let __v_154: G = __loaded[0];
+                                                                                                                                                                                                                let __v_155: G = __loaded[1];
+                                                                                                                                                                                                                let __v_156: G = __loaded[2];
+                                                                                                                                                                                                                match __v_154.as_canonical_u64() {
+                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                    let __v_157: G = __loaded[0];
+                                                                                                                                                                                                                    let __v_158: G = __loaded[1];
+                                                                                                                                                                                                                    let __v_159: G = __loaded[2];
+                                                                                                                                                                                                                    match __v_157.as_canonical_u64() {
+                                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                        let __v_160: G = __loaded[0];
+                                                                                                                                                                                                                        let __v_161: G = __loaded[1];
+                                                                                                                                                                                                                        let __v_162: G = __loaded[2];
+                                                                                                                                                                                                                        match __v_160.as_canonical_u64() {
+                                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                            let __v_163: G = __loaded[0];
+                                                                                                                                                                                                                            let __v_164: G = __loaded[1];
+                                                                                                                                                                                                                            let __v_165: G = __loaded[2];
+                                                                                                                                                                                                                            match __v_163.as_canonical_u64() {
+                                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                let __v_166: G = __loaded[0];
+                                                                                                                                                                                                                                let __v_167: G = __loaded[1];
+                                                                                                                                                                                                                                let __v_168: G = __loaded[2];
+                                                                                                                                                                                                                                match __v_166.as_canonical_u64() {
+                                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                    let __v_169: G = __loaded[0];
+                                                                                                                                                                                                                                    let __v_170: G = __loaded[1];
+                                                                                                                                                                                                                                    let __v_171: G = __loaded[2];
+                                                                                                                                                                                                                                    match __v_169.as_canonical_u64() {
+                                                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                        let __v_172: G = __loaded[0];
+                                                                                                                                                                                                                                        let __v_173: G = __loaded[1];
+                                                                                                                                                                                                                                        let __v_174: G = __loaded[2];
+                                                                                                                                                                                                                                        match __v_172.as_canonical_u64() {
+                                                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                            let __v_175: G = __loaded[0];
+                                                                                                                                                                                                                                            let __v_176: G = __loaded[1];
+                                                                                                                                                                                                                                            let __v_177: G = __loaded[2];
+                                                                                                                                                                                                                                            match __v_175.as_canonical_u64() {
+                                                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                let __v_178: G = __loaded[0];
+                                                                                                                                                                                                                                                let __v_179: G = __loaded[1];
+                                                                                                                                                                                                                                                let __v_180: G = __loaded[2];
+                                                                                                                                                                                                                                                match __v_178.as_canonical_u64() {
+                                                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                    let __v_181: G = __loaded[0];
+                                                                                                                                                                                                                                                    let __v_182: G = __loaded[1];
+                                                                                                                                                                                                                                                    let __v_183: G = __loaded[2];
+                                                                                                                                                                                                                                                    match __v_181.as_canonical_u64() {
+                                                                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                        let __v_184: G = __loaded[0];
+                                                                                                                                                                                                                                                        let __v_185: G = __loaded[1];
+                                                                                                                                                                                                                                                        let __v_186: G = __loaded[2];
+                                                                                                                                                                                                                                                        match __v_184.as_canonical_u64() {
+                                                                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                            let __v_187: G = __loaded[0];
+                                                                                                                                                                                                                                                            let __v_188: G = __loaded[1];
+                                                                                                                                                                                                                                                            let __v_189: G = __loaded[2];
+                                                                                                                                                                                                                                                            match __v_187.as_canonical_u64() {
+                                                                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                                let __v_190: G = __loaded[0];
+                                                                                                                                                                                                                                                                let __v_191: G = __loaded[1];
+                                                                                                                                                                                                                                                                let __v_192: G = __loaded[2];
+                                                                                                                                                                                                                                                                match __v_190.as_canonical_u64() {
+                                                                                                                                                                                                                                                                  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 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)); };
+                                                                                                                                                                                                                                                                    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 __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 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)); };
+        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_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; 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 __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_70] = [__v_7];
+        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)); };
+        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 __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))?; 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_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))?; 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_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))?; 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_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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __ret: [G; OUT_71] = [__v_180];
+                                            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)); };
+                                            return Ok(__ret);
+                                          },
+                                          _ => {
+                                            let __ret: [G; OUT_71] = [__v_5];
+                                            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)); };
+                                            return Ok(__ret);
+                                          },
+                                        }
+                                      },
+                                      _ => {
+                                        let __ret: [G; OUT_71] = [__v_5];
+                                        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)); };
+                                        return Ok(__ret);
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    let __ret: [G; OUT_71] = [__v_5];
+                                    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)); };
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __ret: [G; OUT_71] = [__v_5];
+                                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)); };
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                          _ => {
+                            let __ret: [G; OUT_71] = [__v_5];
+                            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)); };
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        let __ret: [G; OUT_71] = [__v_5];
+                        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)); };
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __ret: [G; OUT_71] = [__v_5];
+                    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)); };
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __ret: [G; OUT_71] = [__v_5];
+                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)); };
+                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 __v_10: G = __loaded[0];
+            let __v_11: G = __loaded[1];
+            let __v_12: G = __loaded[2];
+            let __v_13: G = __loaded[3];
+            let __v_14: G = __loaded[4];
+            let __v_15: G = __loaded[5];
+            let __v_16: G = __loaded[6];
+            let __v_17: G = __loaded[7];
+            let __v_18: G = __loaded[8];
+            let __v_19: G = __loaded[9];
+            let __v_20: G = __loaded[10];
+            let __v_21: G = __loaded[11];
+            let __v_22: G = __loaded[12];
+            let __v_23: G = __loaded[13];
+            let __v_24: G = __loaded[14];
+            let __v_25: G = __loaded[15];
+            let __v_26: G = __loaded[16];
+            let __v_27: G = __loaded[17];
+            let __v_28: G = __loaded[18];
+            let __v_29: G = __loaded[19];
+            let __v_30: G = __loaded[20];
+            let __v_31: G = __loaded[21];
+            let __v_32: G = __loaded[22];
+            let __v_33: G = __loaded[23];
+            let __v_34: G = __loaded[24];
+            let __v_35: G = __loaded[25];
+            let __v_36: G = __loaded[26];
+            let __v_37: G = __loaded[27];
+            let __v_38: G = __loaded[28];
+            let __v_39: G = __loaded[29];
+            let __v_40: G = __loaded[30];
+            let __v_41: G = __loaded[31];
+            let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_71] = [__v_42];
+            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)); };
+            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 __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_3] = { let __args: [G; IN_3] = [__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[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_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; 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 __v_26: G = __r_arr[0];
+        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_26]; 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 __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))?; 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_91: G = __loaded[0];
+        let __v_92: G = __loaded[1];
+        let __v_93: G = __loaded[2];
+        let __v_94: G = __loaded[3];
+        let __v_95: G = __loaded[4];
+        let __v_96: G = __loaded[5];
+        let __v_97: G = __loaded[6];
+        let __v_98: G = __loaded[7];
+        let __v_99: G = __loaded[8];
+        let __v_100: G = __loaded[9];
+        let __v_101: G = __loaded[10];
+        let __v_102: G = __loaded[11];
+        let __v_103: G = __loaded[12];
+        let __v_104: G = __loaded[13];
+        let __v_105: G = __loaded[14];
+        let __v_106: G = __loaded[15];
+        let __v_107: G = __loaded[16];
+        let __v_108: G = __loaded[17];
+        let __v_109: G = __loaded[18];
+        let __v_110: G = __loaded[19];
+        let __v_111: G = __loaded[20];
+        let __v_112: G = __loaded[21];
+        let __v_113: G = __loaded[22];
+        let __v_114: G = __loaded[23];
+        let __v_115: G = __loaded[24];
+        let __v_116: G = __loaded[25];
+        let __v_117: G = __loaded[26];
+        let __v_118: G = __loaded[27];
+        let __v_119: G = __loaded[28];
+        let __v_120: G = __loaded[29];
+        let __v_121: G = __loaded[30];
+        let __v_122: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __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_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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_71] = [__v_187];
+        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)); };
+        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 __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; 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 __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_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 __v_73: G = __r_arr[0];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_74: G = __loaded[0];
+        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_3] = { let __args: [G; IN_3] = [__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[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_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))?; 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_118: G = __loaded[0];
+        let __v_119: G = __loaded[1];
+        let __v_120: G = __loaded[2];
+        let __v_121: G = __loaded[3];
+        let __v_122: G = __loaded[4];
+        let __v_123: G = __loaded[5];
+        let __v_124: G = __loaded[6];
+        let __v_125: G = __loaded[7];
+        let __v_126: G = __loaded[8];
+        let __v_127: G = __loaded[9];
+        let __v_128: G = __loaded[10];
+        let __v_129: G = __loaded[11];
+        let __v_130: G = __loaded[12];
+        let __v_131: G = __loaded[13];
+        let __v_132: G = __loaded[14];
+        let __v_133: G = __loaded[15];
+        let __v_134: G = __loaded[16];
+        let __v_135: G = __loaded[17];
+        let __v_136: G = __loaded[18];
+        let __v_137: G = __loaded[19];
+        let __v_138: G = __loaded[20];
+        let __v_139: G = __loaded[21];
+        let __v_140: G = __loaded[22];
+        let __v_141: G = __loaded[23];
+        let __v_142: G = __loaded[24];
+        let __v_143: G = __loaded[25];
+        let __v_144: G = __loaded[26];
+        let __v_145: G = __loaded[27];
+        let __v_146: G = __loaded[28];
+        let __v_147: G = __loaded[29];
+        let __v_148: G = __loaded[30];
+        let __v_149: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __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_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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = 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_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 __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_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_11(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
+        let __v_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_68] = { let __args: [G; IN_68] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; 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 __v_239: G = __r_arr[0];
+        let __ret: [G; OUT_72] = [__v_239];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        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 __v_73: G = __r_arr[0];
+        let __v_74: G = (__v_73 * __v_7);
+        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 __v_75: G = __r_arr[0];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_76: G = __loaded[0];
+        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_3] = { let __args: [G; IN_3] = [__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[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_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))?; 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_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))?; 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_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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = 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_68] = { let __args: [G; IN_68] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; 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 __v_196: G = __r_arr[0];
+        let __ret: [G; OUT_72] = [__v_196];
+        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)); };
+        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 __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 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)); };
+    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 __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 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)); };
+    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 __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; 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 __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 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)); };
+    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 __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 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)); };
+        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; 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 __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 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)); };
+        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 __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() {
+      0u64 => {
+        let __ret: [G; OUT_77] = [__v_2, __v_3];
+        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)); };
+        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 __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 __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __ret: [G; OUT_78] = [__v_1, __v_2];
+    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)); };
+    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 __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 __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; 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_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 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)); };
+    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 __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 __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; 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_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 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)); };
+    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 __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 __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; 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_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; 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_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; 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_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 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)); };
+    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 __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 __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; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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 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)); };
+    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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__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 __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 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)); };
+    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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__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 __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; 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 __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; 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 __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; 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 __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 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)); };
+    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 __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_85] = [__v_4, __v_0];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__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 __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; 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 __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; 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 __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; 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 __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; 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 __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_85] = [__v_44, __v_41];
+        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)); };
+        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 __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_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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__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 __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; 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 __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; 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_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_86] = [__v_13, __v_9];
+            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)); };
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3]; 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 __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; 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_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_86] = [__v_13, __v_9];
+            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)); };
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_3]; 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 __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; 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_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_86] = [__v_13, __v_9];
+            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)); };
+            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; 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_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_86] = [__v_11, __v_7];
+            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)); };
+            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; 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_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_86] = [__v_11, __v_7];
+            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)); };
+            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; 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_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_86] = [__v_11, __v_7];
+            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)); };
+            return Ok(__ret);
+          },
+          6u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 __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; 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 __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 = 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_86] = [__v_15, __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)); };
+            return Ok(__ret);
+          },
+          7u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 __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; 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 __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 = 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_86] = [__v_15, __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)); };
+            return Ok(__ret);
+          },
+          8u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 __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; 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 __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 = 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_86] = [__v_15, __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)); };
+            return Ok(__ret);
+          },
+          9u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 __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; 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_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_86] = [__v_13, __v_9];
+            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)); };
+            return Ok(__ret);
+          },
+          10u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 __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; 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_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_86] = [__v_14, __v_9];
+            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)); };
+            return Ok(__ret);
+          },
+          11u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 __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; 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_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_86] = [__v_14, __v_9];
+            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)); };
+            return Ok(__ret);
+          },
+          12u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 __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; 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_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_86] = [__v_14, __v_9];
+            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)); };
+            return Ok(__ret);
+          },
+          13u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 __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; 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_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_86] = [__v_14, __v_9];
+            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)); };
+            return Ok(__ret);
+          },
+          14u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 __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; 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_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_86] = [__v_14, __v_9];
+            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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 __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; 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_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_86] = [__v_14, __v_9];
+            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)); };
+            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 __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_87] = [__v_4, __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)); };
+        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 __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; 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 __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_87] = [__v_9, __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)); };
+        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 __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 __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; 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 __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; 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 __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; 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 __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 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)); };
+    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 __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_89] = [__v_4, __v_0];
+        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);
+      },
+      _ => {
+        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 __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; 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 __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; 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 __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; 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 __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; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+        let __v_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_22, __v_20];
+        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 = 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 __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 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)); };
+        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; 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_8: G = __r_arr[0];
+            let __v_9: G = (__v_3 + __v_8);
+            let __ret: [G; OUT_90] = [__v_9];
+            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)); };
+            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; 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_7: G = __r_arr[0];
+            let __ret: [G; OUT_90] = [__v_7];
+            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)); };
+            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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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_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; 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 __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; 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 __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; 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 __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; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+    let __v_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; 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_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 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)); };
+    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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_92] = [__v_70];
+    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)); };
+    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 __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_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_93] = [__v_4, __v_7, __v_0];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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_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; 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 __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; 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 __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; 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 __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; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+        let __v_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; 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_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; 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 __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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_93] = [__v_204, __v_218, __v_202];
+        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)); };
+        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 __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 __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 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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; 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 __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; 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 __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 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)); };
+        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 __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_95] = [__v_4, __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)); };
+        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 __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; 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_11, __v_7];
+            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)); };
+            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_95] = [__v_10, __v_7];
+            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)); };
+            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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_96] = [__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[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)); };
+    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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_80] = { let __args: [G; IN_80] = [__v_70]; 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 __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; 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 __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; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_94(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } } else { aiur_fn_94(__args, record, io_buffer, __cu)? } };
+    let __v_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; 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_87, __v_155]; 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 __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 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)); };
+    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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_98] = [__v_12];
+    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)); };
+    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 __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; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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; 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_40: G = __r_arr[0];
+    let __ret: [G; OUT_99] = [__v_40];
+    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)); };
+    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 __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 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)); };
+    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 __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))?; 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_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))?; 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_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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_163];
+    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)); };
+    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 __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; 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 __v_3: G = __r_arr[0];
+        let __ret: [G; OUT_102] = [__v_3];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_2, __v_1]; 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 __v_3: G = __r_arr[0];
+        let __ret: [G; OUT_102] = [__v_3];
+        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)); };
+        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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_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)); };
+        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 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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
+            let __ret: [G; OUT_103] = [__v_7];
+            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)); };
+            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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_104] = [__v_8];
+        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)); };
+        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 => {
+            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; 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 __v_11: G = __r_arr[0];
+                let __ret: [G; OUT_104] = [__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)); };
+                return Ok(__ret);
+              },
+              _ => {
+                let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+                let __v_11: G = __loaded[0];
+                let __v_12: G = __loaded[1];
+                let __v_13: G = __loaded[2];
+                let __v_14: G = __loaded[3];
+                let __v_15: G = __loaded[4];
+                let __v_16: G = __loaded[5];
+                let __v_17: G = __loaded[6];
+                let __v_18: G = __loaded[7];
+                let __v_19: G = __loaded[8];
+                let __v_20: G = __loaded[9];
+                match __v_11.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; 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 __v_21: G = __r_arr[0];
+                    let __ret: [G; OUT_104] = [__v_21];
+                    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)); };
+                    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; 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 __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_104] = [__v_23];
+                    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)); };
+                    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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_12: G = G::from_u64(256);
+        let __v_13: G = (__v_12 * __v_4);
+        let __v_14: G = G::from_u64(65536);
+        let __v_15: G = (__v_14 * __v_5);
+        let __v_16: G = G::from_u64(16777216);
+        let __v_17: G = (__v_16 * __v_6);
+        let __v_18: G = G::from_u64(4294967296);
+        let __v_19: G = (__v_18 * __v_7);
+        let __v_20: G = G::from_u64(1099511627776);
+        let __v_21: G = (__v_20 * __v_8);
+        let __v_22: G = G::from_u64(281474976710656);
+        let __v_23: G = (__v_22 * __v_9);
+        let __v_24: G = G::from_u64(72057594037927936);
+        let __v_25: G = (__v_24 * __v_10);
+        let __v_26: G = (__v_23 + __v_25);
+        let __v_27: G = (__v_21 + __v_26);
+        let __v_28: G = (__v_19 + __v_27);
+        let __v_29: G = (__v_17 + __v_28);
+        let __v_30: G = (__v_15 + __v_29);
+        let __v_31: G = (__v_13 + __v_30);
+        let __v_32: G = (__v_3 + __v_31);
+        let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes();
+        let __v_33: G = G::from_u8(__gb[0]);
+        let __v_34: G = G::from_u8(__gb[1]);
+        let __v_35: G = G::from_u8(__gb[2]);
+        let __v_36: G = G::from_u8(__gb[3]);
+        let __v_37: G = G::from_u8(__gb[4]);
+        let __v_38: G = G::from_u8(__gb[5]);
+        let __v_39: G = G::from_u8(__gb[6]);
+        let __v_40: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_41: G = G::from_u64(1020);
+        let __v_42: G = (__v_40 - __v_41);
+        let __v_43: G = (__v_39 + __v_42);
+        let __v_44: G = (__v_38 + __v_43);
+        let __v_45: G = (__v_37 + __v_44);
+        let __v_46: G = G::from_bool((__v_45 == G::ZERO));
+        let __v_47: G = (__v_35 + __v_36);
+        let __v_48: G = (__v_34 + __v_47);
+        let __v_49: G = (__v_33 + __v_48);
+        let __v_50: G = G::from_bool((__v_49 == G::ZERO));
+        let __v_51: G = G::from_u64(256);
+        let __v_52: G = (__v_51 * __v_34);
+        let __v_53: G = G::from_u64(65536);
+        let __v_54: G = (__v_53 * __v_35);
+        let __v_55: G = G::from_u64(16777216);
+        let __v_56: G = (__v_55 * __v_36);
+        let __v_57: G = G::from_u64(4294967296);
+        let __v_58: G = (__v_57 * __v_37);
+        let __v_59: G = G::from_u64(1099511627776);
+        let __v_60: G = (__v_59 * __v_38);
+        let __v_61: G = G::from_u64(281474976710656);
+        let __v_62: G = (__v_61 * __v_39);
+        let __v_63: G = G::from_u64(72057594037927936);
+        let __v_64: G = (__v_63 * __v_40);
+        let __v_65: G = (__v_62 + __v_64);
+        let __v_66: G = (__v_60 + __v_65);
+        let __v_67: G = (__v_58 + __v_66);
+        let __v_68: G = (__v_56 + __v_67);
+        let __v_69: G = (__v_54 + __v_68);
+        let __v_70: G = (__v_52 + __v_69);
+        let __v_71: G = (__v_33 + __v_70);
+        if (__v_71 != __v_32) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
+        }
+        let __v_72: G = G::from_u64(1);
+        let __v_73: G = G::from_u64(1);
+        let __v_74: G = (__v_73 - __v_50);
+        let __v_75: G = (__v_46 * __v_74);
+        let __v_76: G = (__v_72 - __v_75);
+        let __v_77: G = G::from_u64(1);
+        if (__v_76 != __v_77) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
+        }
+        let __v_78: G = G::from_u64(1);
+        let __ret: [G; OUT_105] = [__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[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)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        match __v_12.as_canonical_u64() {
+          1u64 => {
+            let __v_15: G = G::from_u64(0);
+            let __v_16: G = G::from_u64(0);
+            let __v_17: G = G::from_u64(0);
+            let __v_18: G = G::from_u64(0);
+            let __v_19: G = G::from_u64(0);
+            let __v_20: G = G::from_u64(0);
+            let __v_21: G = G::from_u64(0);
+            let __v_22: G = G::from_u64(0);
+            let __v_23: G = G::from_u64(0);
+            let __ret: [G; OUT_105] = [__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[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)); };
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_13, __v_14]; 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_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 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)); };
+            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 __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; 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 = __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))?; 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_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))?; 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_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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                                        let __v_121: G = __loaded[0];
+                                        let __v_122: G = __loaded[1];
+                                        let __v_123: G = __loaded[2];
+                                        let __v_124: G = __loaded[3];
+                                        let __v_125: G = __loaded[4];
+                                        let __v_126: G = __loaded[5];
+                                        let __v_127: G = __loaded[6];
+                                        let __v_128: G = __loaded[7];
+                                        let __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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __ret: [G; OUT_106] = [__v_187];
+                                        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)); };
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        let __ret: [G; OUT_106] = [__v_5];
+                                        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)); };
+                                        return Ok(__ret);
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    let __ret: [G; OUT_106] = [__v_5];
+                                    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)); };
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __ret: [G; OUT_106] = [__v_5];
+                                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)); };
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                          _ => {
+                            let __ret: [G; OUT_106] = [__v_5];
+                            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)); };
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        let __ret: [G; OUT_106] = [__v_5];
+                        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)); };
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __ret: [G; OUT_106] = [__v_5];
+                    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)); };
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __ret: [G; OUT_106] = [__v_5];
+                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)); };
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __ret: [G; OUT_106] = [__v_5];
+            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)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_14, __v_15]; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_103: G = __loaded[0];
+        let __v_104: G = __loaded[1];
+        let __v_105: G = __loaded[2];
+        let __v_106: G = __loaded[3];
+        let __v_107: G = __loaded[4];
+        let __v_108: G = __loaded[5];
+        let __v_109: G = __loaded[6];
+        let __v_110: G = __loaded[7];
+        let __v_111: G = __loaded[8];
+        let __v_112: G = __loaded[9];
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() {
+  1u64 => {
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_113: G = __loaded[0];
+    let __v_114: G = __loaded[1];
+    let __v_115: G = __loaded[2];
+    match __v_113.as_canonical_u64() {
+      1u64 => {
+        let __v_116: G = G::from_u64(1);
+        break '__mc_0 [__v_116];
+      },
+      _ => {
+        let __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_121: G = __loaded[0];
+        let __v_122: G = __loaded[1];
+        let __v_123: G = __loaded[2];
+        let __v_124: G = __loaded[3];
+        let __v_125: G = __loaded[4];
+        let __v_126: G = __loaded[5];
+        let __v_127: G = __loaded[6];
+        let __v_128: G = __loaded[7];
+        let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__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[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_129: G = __r_arr[0];
+        let __v_130: G = (__v_113 * __v_129);
+        let __v_131: G = G::from_u64(2);
+        let __v_132: G = (__v_131 * __v_120);
+        let __v_133: G = G::from_u64(8);
+        let __v_134: G = (__v_133 * __v_130);
+        let __v_135: G = (__v_132 + __v_134);
+        let __v_136: G = (__v_117 + __v_135);
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_137: G = __loaded[0];
+        let __v_138: G = __loaded[1];
+        let __v_139: G = __loaded[2];
+        let __v_140: G = __loaded[3];
+        let __v_141: G = __loaded[4];
+        let __v_142: G = __loaded[5];
+        let __v_143: G = __loaded[6];
+        let __v_144: G = __loaded[7];
+        let __v_145: G = __loaded[8];
+        let __v_146: G = __loaded[9];
+        let __v_147: G = __loaded[10];
+        let __v_148: G = __loaded[11];
+        let __v_149: G = __loaded[12];
+        let __v_150: G = __loaded[13];
+        let __v_151: G = __loaded[14];
+        let __v_152: G = __loaded[15];
+        let __v_153: G = __loaded[16];
+        let __v_154: G = __loaded[17];
+        let __v_155: G = __loaded[18];
+        let __v_156: G = __loaded[19];
+        let __v_157: G = __loaded[20];
+        let __v_158: G = __loaded[21];
+        let __v_159: G = __loaded[22];
+        let __v_160: G = __loaded[23];
+        let __v_161: G = __loaded[24];
+        let __v_162: G = __loaded[25];
+        let __v_163: G = __loaded[26];
+        let __v_164: G = __loaded[27];
+        let __v_165: G = __loaded[28];
+        let __v_166: G = __loaded[29];
+        let __v_167: G = __loaded[30];
+        let __v_168: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_169: G = __loaded[0];
+        let __v_170: G = __loaded[1];
+        let __v_171: G = __loaded[2];
+        let __v_172: G = __loaded[3];
+        let __v_173: G = __loaded[4];
+        let __v_174: G = __loaded[5];
+        let __v_175: G = __loaded[6];
+        let __v_176: G = __loaded[7];
+        let __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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_106] = [__v_233];
+            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)); };
+            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))?; 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_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_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_11(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
+                let __v_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_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_106] = { let __args: [G; IN_106] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; 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 __v_285: G = __r_arr[0];
+                let __ret: [G; OUT_106] = [__v_285];
+                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)); };
+                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_106] = { let __args: [G; IN_106] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; 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 __v_235: G = __r_arr[0];
+                let __ret: [G; OUT_106] = [__v_235];
+                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)); };
+                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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_47: G = G::from_u64(1);
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; 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 __v_50: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_50]; 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 __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 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)); };
+    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 __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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_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_106] = { let __args: [G; IN_106] = [__v_38, __v_3, __v_39, __v_48, __v_49, __v_52]; 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 __v_53: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_53]; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_108] = [__v_86];
+    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)); };
+    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 __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; 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_4: G = __r_arr[0];
+    match __v_4.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_109] = [__v_3];
+        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);
+      },
+      _ => {
+        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_1, __v_2]; 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_3, __v_5]; 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 __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_109] = [__v_6];
+        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 = 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 __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_110] = [__v_4];
+        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);
+      },
+      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; 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_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 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);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_111: usize = 6;
+const IN_111: usize = 6;
+const OUT_111: usize = 2;
+fn aiur_fn_111(
+  inp: [G; IN_111],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_111], ExecError> {
+  stacker::maybe_grow(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 __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() {
+      1u64 => {
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_4]; 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_9: G = __r_arr[0];
+        let __ret: [G; OUT_111] = [__v_0, __v_9];
+        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);
+      },
+      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_101] = { let __args: [G; IN_101] = [__v_0, __v_7]; 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 __v_12: G = __r_arr[0];
+    break '__mc_0 [__v_12];
+  },
+  _ => {
+    let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_7, __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 __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_103] = { let __args: [G; IN_103] = [__v_2, __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_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_108] = { let __args: [G; IN_108] = [__v_1, __v_2, __v_5]; 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_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_12, __v_14]; 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 __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_111] = { let __args: [G; IN_111] = [__v_14, __v_1, __v_2, __v_8, __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 __v_18: G = __r_arr[1];
+            let __ret: [G; OUT_111] = [__v_17, __v_18];
+            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);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_112: usize = 5;
+const IN_112: usize = 5;
+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 __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_108] = { let __args: [G; IN_108] = [__v_0, __v_1, __v_4]; 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_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_111] = { let __args: [G; IN_111] = [__v_5, __v_0, __v_1, __v_3, __v_2, __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 __v_8: G = __r_arr[0];
+    let __v_9: G = __r_arr[1];
+    let __ret: [G; OUT_112] = [__v_8, __v_9];
+    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);
+  })
+}
+
+const INPUT_SIZE_113: usize = 6;
+const IN_113: usize = 6;
+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 __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_108] = { let __args: [G; IN_108] = [__v_1, __v_2, __v_5]; 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_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_111] = { let __args: [G; IN_111] = [__v_6, __v_1, __v_2, __v_4, __v_3, __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 __v_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_0, __v_10]; 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 __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_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)); };
+    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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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_114] = [__v_1];
+        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);
+      },
+      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_114] = { let __args: [G; IN_114] = [__v_4, __v_6]; 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 __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_114] = [__v_7];
+        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);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_115], 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 __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_115] = [__v_5];
+        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);
+      },
+      0u64 => {
+        let __v_5: G = (__v_0 * __v_0);
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5, __v_4]; 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_6: G = __r_arr[0];
+        match __v_3.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_115] = [__v_6];
+            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);
+          },
+          _ => {
+            let __v_7: G = (__v_0 * __v_6);
+            let __ret: [G; OUT_115] = [__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)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_116: usize = 8;
+const IN_116: usize = 8;
+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 __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_165] = { let __args: [G; IN_165] = [__v_9]; 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 __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_114] = { let __args: [G; IN_114] = [__v_0, __v_13]; 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 __v_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10, __v_14]; 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_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_116] = [__v_82, __v_83];
+    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);
+  })
+}
+
+const INPUT_SIZE_117: usize = 2;
+const IN_117: usize = 2;
+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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(7);
+    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__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 __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_114] = { let __args: [G; IN_114] = [__v_0, __v_6]; 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 __v_7: G = __r_arr[0];
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3, __v_7]; 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_8: G = __r_arr[0];
+    let __v_9: G = (__v_2 * __v_8);
+    let __ret: [G; OUT_117] = [__v_9];
+    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);
+  })
+}
+
+const INPUT_SIZE_118: usize = 8;
+const IN_118: usize = 8;
+const OUT_118: usize = 4;
+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 __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() {
+      1u64 => {
+        let __ret: [G; OUT_118] = [__v_4, __v_5, __v_6, __v_7];
+        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)); };
+        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_118] = { let __args: [G; IN_118] = [__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[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_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_118] = [__v_64, __v_65, __v_66, __v_67];
+            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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_8.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 __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_119] = [__v_1];
+        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);
+      },
+      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_119] = { let __args: [G; IN_119] = [__v_5, __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 __v_96: G = __r_arr[0];
+        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_97: G = __r_arr[0];
+        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_98: G = __r_arr[0];
+        let __ret: [G; OUT_119] = [__v_98];
+        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_2.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_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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_120] = [__v_1];
+        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);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_4, __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 __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
+        let __ret: [G; OUT_120] = [__v_6];
+        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);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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 __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_121] = [__v_1];
+        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);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_4, __v_1]; 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
+        let __ret: [G; OUT_121] = [__v_6];
+        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);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_122: usize = 3;
+const IN_122: usize = 3;
+const OUT_122: usize = 1;
+fn aiur_fn_122(
+  inp: [G; IN_122],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_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];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_122] = [__v_2];
+        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);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1, __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 __v_3: G = __r_arr[0];
+        let __ret: [G; OUT_122] = [__v_3];
+        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_0.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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_123] = [__v_0];
+        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);
+      },
+      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_158] = { let __args: [G; IN_158] = [__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[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 __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_13, __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_14: G = __r_arr[0];
+        let __ret: [G; OUT_123] = [__v_14];
+        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);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_124: usize = 10;
+const IN_124: usize = 10;
+const OUT_124: usize = 2;
+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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_0, __v_12];
+        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);
+      },
+      _ => {
+        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__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[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_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_157] = { let __args: [G; IN_157] = [__v_10, __v_13, __v_9]; 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 __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; 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_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_124] = [__v_15, __v_16];
+        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);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_125: usize = 4;
+const IN_125: usize = 4;
+const OUT_125: usize = 2;
+fn aiur_fn_125(
+  inp: [G; IN_125],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_125], ExecError> {
+  stacker::maybe_grow(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_125] = [__v_9, __v_0];
+        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);
+      },
+      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_159] = { let __args: [G; IN_159] = [__v_0, __v_5]; 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 __v_17: G = __r_arr[0];
+            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__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[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_18: G = __r_arr[0];
+            let __v_19: G = __r_arr[1];
+            let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_18, __v_19]; 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_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_125] = { let __args: [G; IN_125] = [__v_36, __v_6, __v_16, __v_3]; 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_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_125] = [__v_83, __v_39];
+            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);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_126: usize = 5;
+const IN_126: usize = 5;
+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 __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_126] = [__v_5];
+        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_231] = { let __args: [G; IN_231] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__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 __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_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)); };
+            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_126] = { let __args: [G; IN_126] = [__v_0, __v_1, __v_10, __v_12, __v_4]; 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_13: G = __r_arr[0];
+            let __ret: [G; OUT_126] = [__v_13];
+            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);
+          },
+        }
+      },
+    }
+  })
+}
+
+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_127], ExecError> {
+  stacker::maybe_grow(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_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_127] = [__v_6];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1, __v_2, __v_4, __v_3]; 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_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_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_7]; 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_8: G = __r_arr[0];
+            let __ret: [G; OUT_127] = [__v_8];
+            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)); };
+            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_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_12]; 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_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_127] = [__v_14];
+            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)); };
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_128: usize = 8;
+const IN_128: usize = 8;
+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_128], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = 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() {
+      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_128] = [__v_17];
+        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);
+      },
+      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_118] = { let __args: [G; IN_118] = [__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[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_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_128] = [__v_34];
+                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);
+              },
+              _ => {
+                let __v_17: G = G::from_u64(0);
+                let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__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[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_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_128] = [__v_19];
+                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);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_129], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_9: G = G::from_u64(1);
+        let __ret: [G; OUT_129] = [__v_9];
+        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);
+      },
+      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_129] = [__v_19];
+                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 __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_8, __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 __v_11: G = __r_arr[0];
+                let __ret: [G; OUT_129] = [__v_11];
+                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);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_130: usize = 2;
+const IN_130: usize = 2;
+const OUT_130: usize = 1;
+fn aiur_fn_130(
+  inp: [G; IN_130],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_130], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_130] = [__v_2];
+        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)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_130] = [__v_2];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_131: usize = 10;
+const IN_131: usize = 10;
+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 __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_238] = { let __args: [G; IN_238] = [__v_2, __v_10]; 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 __v_11: G = __r_arr[0];
+    let __v_12: G = G::from_u64(7);
+    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__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 __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_114] = { let __args: [G; IN_114] = [__v_11, __v_16]; 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 __v_17: G = __r_arr[0];
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_13, __v_17]; 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_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_240] = { let __args: [G; IN_240] = [__v_6]; 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 __v_40: G = __r_arr[0];
+    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_7]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+    let __v_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_128] = { let __args: [G; IN_128] = [__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[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_45: G = __r_arr[0];
+    let __ret: [G; OUT_131] = [__v_45];
+    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 = 11;
+const IN_132: usize = 11;
+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 = G::from_u64(0);
+    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__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 __v_12: G = __r_arr[0];
+    let __v_13: G = G::from_u64(1);
+    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_8, __v_13]; 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 __v_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_4]; 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 __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_131] = { let __args: [G; IN_131] = [__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[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_25: G = __r_arr[0];
+    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__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[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_26: G = __r_arr[0];
+    let __ret: [G; OUT_132] = [__v_26];
+    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);
+  })
+}
+
+const INPUT_SIZE_133: usize = 13;
+const IN_133: usize = 13;
+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 __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_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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_6, __v_4]; 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 __v_13: G = __r_arr[0];
+        let __v_14: G = (__v_13 + __v_3);
+        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_9, __v_4]; 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 __v_15: G = __r_arr[0];
+        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_10, __v_4]; 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 __v_16: G = __r_arr[0];
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__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[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_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_133] = { let __args: [G; IN_133] = [__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[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_22: G = __r_arr[0];
+        let __ret: [G; OUT_133] = [__v_22];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_134: usize = 13;
+const IN_134: usize = 13;
+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 __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_134] = [__v_0];
+        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);
+      },
+      _ => {
+        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_6, __v_4]; 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 __v_13: G = __r_arr[0];
+        let __v_14: G = (__v_13 + __v_3);
+        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_9, __v_4]; 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 __v_15: G = __r_arr[0];
+        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_10, __v_4]; 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 __v_16: G = __r_arr[0];
+        let __v_17: G = G::from_u64(0);
+        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_16, __v_17]; 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 __v_18: G = __r_arr[0];
+        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__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[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_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_134] = { let __args: [G; IN_134] = [__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[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_24: G = __r_arr[0];
+        let __ret: [G; OUT_134] = [__v_24];
+        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 = 15;
+const IN_135: usize = 15;
+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 __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_135] = [__v_0];
+        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);
+      },
+      _ => {
+        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_8, __v_4]; 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 __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_135] = { let __args: [G; IN_135] = [__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[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_21: G = __r_arr[0];
+            let __ret: [G; OUT_135] = [__v_21];
+            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);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_7, __v_4]; 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 __v_17: G = __r_arr[0];
+            let __v_18: G = (__v_17 + __v_3);
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_11, __v_6]; 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 __v_19: G = __r_arr[0];
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__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 __v_20: G = __r_arr[0];
+            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__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[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 __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_135] = { let __args: [G; IN_135] = [__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[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_28: G = __r_arr[0];
+            let __ret: [G; OUT_135] = [__v_28];
+            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);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_136: usize = 15;
+const IN_136: usize = 15;
+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 __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_136] = [__v_0];
+        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_15: G = G::from_u64(3);
+        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_15]; 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 __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(0);
+            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_6, __v_10, __v_5, __v_7, __v_18]; 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_19: G = __r_arr[0];
+            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_19]; 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_20: G = __r_arr[0];
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__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 __v_21: G = __r_arr[0];
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__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 __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_238] = { let __args: [G; IN_238] = [__v_8, __v_26]; 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 __v_27: G = __r_arr[0];
+            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2, __v_16, __v_19, __v_27, __v_17, __v_20]; 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_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_135] = { let __args: [G; IN_135] = [__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[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_32: G = __r_arr[0];
+            let __ret: [G; OUT_136] = [__v_32];
+            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);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_137: usize = 4;
+const IN_137: usize = 4;
+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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_137] = [__v_6];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__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 __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_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_8, __v_10]; 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 __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_137] = [__v_12];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_138: usize = 1;
+const IN_138: usize = 1;
+const OUT_138: usize = 1;
+fn aiur_fn_138(
+  inp: [G; IN_138],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_138], 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_138] = [__v_4];
+        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 __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3]; 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_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_138] = [__v_4];
+            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);
+          },
+          _ => {
+            let __ret: [G; OUT_138] = [__v_2];
+            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_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_139: usize = 5;
+const IN_139: usize = 5;
+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 __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_139] = [__v_7];
+        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 __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_4]; 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 __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_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_8, __v_10]; 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_11: G = __r_arr[0];
+            let __ret: [G; OUT_139] = [__v_11];
+            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);
+          },
+          1u64 => {
+            let __v_7: G = G::from_u64(0);
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_0, __v_4]; 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 __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_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_11, __v_13]; 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_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_139] = [__v_15];
+            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_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_140: usize = 5;
+const IN_140: usize = 5;
+const OUT_140: usize = 4;
+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 __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_140] = [__v_1, __v_2, __v_3, __v_4];
+        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 __ret: [G; OUT_140] = [__v_3, __v_4, __v_1, __v_2];
+        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);
+      },
+    }
+  })
+}
+
+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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_141] = [__v_194];
+    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);
+  })
+}
+
+const INPUT_SIZE_142: usize = 6;
+const IN_142: usize = 6;
+const OUT_142: usize = 3;
+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 __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_142] = [__v_0, __v_1, __v_5];
+        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);
+      },
+      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_164] = { let __args: [G; IN_164] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__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_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_142] = [__v_26, __v_27, __v_12];
+                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);
+              },
+              _ => {
+                let __ret: [G; OUT_142] = [__v_0, __v_1, __v_5];
+                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);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_143: usize = 9;
+const IN_143: usize = 9;
+const OUT_143: usize = 2;
+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 __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; 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_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 __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_143] = [__v_0, __v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_14: G = __loaded[0];
+        let __v_15: G = __loaded[1];
+        let __v_16: G = __loaded[2];
+        let __v_17: G = __loaded[3];
+        match __v_14.as_canonical_u64() {
+          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_233] = { let __args: [G; IN_233] = [__v_11, __v_26]; 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 __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_116] = { let __args: [G; IN_116] = [__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[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_105: G = __r_arr[0];
+                        let __v_106: G = __r_arr[1];
+                        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_105, __v_106, __v_25, __v_15, __v_16, __v_7]; 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_107: G = __r_arr[0];
+                        let __v_108: G = __r_arr[1];
+                        let __v_109: G = __r_arr[2];
+                        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_11]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+                        let __v_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_113] = { let __args: [G; IN_113] = [__v_19, __v_235, __v_240, __v_23, __v_12, __v_25]; 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_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_143] = { let __args: [G; IN_143] = [__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[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 __v_243: G = __r_arr[0];
+                        let __v_244: G = __r_arr[1];
+                        let __ret: [G; OUT_143] = [__v_243, __v_244];
+                        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)); };
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
+                      },
+                    }
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_144: usize = 25;
+const IN_144: usize = 25;
+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_144], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    match __v_1.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_15, __v_19, __v_18, __v_20]; 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_25: G = __r_arr[0];
+        let __v_26: G = G::from_u64(0);
+        let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_15, __v_19, __v_18, __v_26]; 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 __v_27: G = __r_arr[0];
+        let __v_28: G = G::from_u64(0);
+        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_28]; 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 __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_133] = { let __args: [G; IN_133] = [__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[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_32: G = __r_arr[0];
+            let __v_33: G = G::from_u64(1);
+            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_33]; 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 __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_133] = { let __args: [G; IN_133] = [__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[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_37: G = __r_arr[0];
+                let __v_38: G = G::from_u64(2);
+                let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_38]; 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 __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_134] = { let __args: [G; IN_134] = [__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[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_42: G = __r_arr[0];
+                    let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__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[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_43: G = __r_arr[0];
+                    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_43, __v_19]; 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_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_143] = { let __args: [G; IN_143] = [__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[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 __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_233] = { let __args: [G; IN_233] = [__v_23, __v_54]; 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 __v_55: G = __r_arr[0];
+                            let __v_56: G = __r_arr[1];
+                            let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_2]; 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 __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_235] = { let __args: [G; IN_235] = [__v_1]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+                            let __v_61: G = __r_arr[0];
+                            let __v_62: G = G::from_u64(3);
+                            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__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_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_243] = { let __args: [G; IN_243] = [__v_29]; 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_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_113] = { let __args: [G; IN_113] = [__v_10, __v_29, __v_27, __v_0, __v_30, __v_20]; 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_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_243] = { let __args: [G; IN_243] = [__v_34]; 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_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_113] = { let __args: [G; IN_113] = [__v_11, __v_34, __v_27, __v_0, __v_35, __v_20]; 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_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_243] = { let __args: [G; IN_243] = [__v_39]; 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_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_113] = { let __args: [G; IN_113] = [__v_12, __v_39, __v_27, __v_0, __v_40, __v_20]; 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_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_144] = [__v_95];
+                            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);
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_145: usize = 25;
+const IN_145: usize = 25;
+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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_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_145] = [__v_29];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_0, __v_1, __v_20]; 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 __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_144] = { let __args: [G; IN_144] = [__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[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 __v_32: G = __r_arr[0];
+        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__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[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_33: G = __r_arr[0];
+        let __ret: [G; OUT_145] = [__v_33];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_146: usize = 31;
+const IN_146: usize = 31;
+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_146], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    match __v_6.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__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 __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_121] = { let __args: [G; IN_121] = [__v_5, __v_34]; 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_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_121] = { let __args: [G; IN_121] = [__v_3, __v_35]; 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_36: G = __r_arr[0];
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2, __v_36]; 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_37: G = __r_arr[0];
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1, __v_37]; 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_38: G = __r_arr[0];
+        let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_0, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+        let __v_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_155] = { let __args: [G; IN_155] = [__v_39, __v_42]; 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_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_125] = { let __args: [G; IN_125] = [__v_59, __v_6, __v_7, __v_29]; 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_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_119] = { let __args: [G; IN_119] = [__v_9, __v_107]; 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_108: G = __r_arr[0];
+        let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_104, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+        let __v_109: G = __r_arr[0];
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_109, __v_6]; 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_110: G = __r_arr[0];
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__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[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_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_240] = { let __args: [G; IN_240] = [__v_7]; 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 __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_235] = { let __args: [G; IN_235] = [__v_8]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+        let __v_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_235] = { let __args: [G; IN_235] = [__v_9]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+        let __v_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_145] = { let __args: [G; IN_145] = [__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[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_127: G = __r_arr[0];
+        let __ret: [G; OUT_146] = [__v_127];
+        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);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_147: usize = 2;
+const IN_147: usize = 2;
+const OUT_147: usize = 1;
+fn aiur_fn_147(
+  inp: [G; IN_147],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_147], ExecError> {
+  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_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_147] = [__v_4];
+    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);
+  })
+}
+
+const INPUT_SIZE_148: usize = 1;
+const IN_148: usize = 1;
+const OUT_148: usize = 1;
+fn aiur_fn_148(
+  inp: [G; IN_148],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_148], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_148] = [__v_5];
+        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; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __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_148] = [__v_11];
+            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);
+          },
+          _ => {
+            let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__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_9: G = __r_arr[0];
+            let __ret: [G; OUT_148] = [__v_9];
+            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_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_149: usize = 9;
+const IN_149: usize = 9;
+const OUT_149: usize = 1;
+fn aiur_fn_149(
+  inp: [G; IN_149],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_149], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = 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_149] = [__v_24];
+    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);
+  })
+}
+
+const INPUT_SIZE_150: usize = 33;
+const IN_150: usize = 33;
+const OUT_150: usize = 1;
+fn aiur_fn_150(
+  inp: [G; IN_150],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_150], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = 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_149] = { let __args: [G; IN_149] = [__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[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_33: G = __r_arr[0];
+    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_34: G = __r_arr[0];
+    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_35: G = __r_arr[0];
+    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_36: G = __r_arr[0];
+    let __ret: [G; OUT_150] = [__v_36];
+    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);
+  })
+}
+
+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 __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_151] = [__v_1];
+        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)); };
+        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_151] = { let __args: [G; IN_151] = [__v_4, __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_37: G = __r_arr[0];
+        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_38: G = __r_arr[0];
+        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_39: G = __r_arr[0];
+        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_149] = { let __args: [G; IN_149] = [__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[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_41: G = __r_arr[0];
+        let __ret: [G; OUT_151] = [__v_41];
+        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)); };
+        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 __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_152] = [__v_1];
+        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);
+      },
+      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_152] = { let __args: [G; IN_152] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_13: G = __r_arr[0];
+        let __ret: [G; OUT_152] = [__v_13];
+        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);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_153: usize = 2;
+const IN_153: usize = 2;
+const OUT_153: usize = 10;
+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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(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_68] = { let __args: [G; IN_68] = [__v_0, __v_39, __v_40, __v_41, __v_50, __v_51, __v_54]; 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 __v_55: G = __r_arr[0];
+        let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_55]; 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 __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_98] = { let __args: [G; IN_98] = [__v_84, __v_85, __v_86, __v_87, __v_90]; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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_114] = { let __args: [G; IN_114] = [__v_98, __v_101]; 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 __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() {
+          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() {
+              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() {
+                      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_153] = [__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[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)); };
+                                        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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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() {
+                      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_153] = [__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[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)); };
+                                    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_154: usize = 2;
+const IN_154: usize = 2;
+const OUT_154: usize = 10;
+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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_0, __v_1]; 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_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_154] = [__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[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 __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_10, __v_11]; 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_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_154] = [__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[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);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_155: usize = 2;
+const IN_155: usize = 2;
+const OUT_155: usize = 18;
+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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__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_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_154] = { let __args: [G; IN_154] = [__v_10, __v_11]; 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_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_155] = [__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[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);
+  })
+}
+
+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 __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_156] = [__v_4];
+        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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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_156] = { let __args: [G; IN_156] = [__v_4, __v_7]; 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_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_156] = [__v_9];
+            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);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_157: usize = 3;
+const IN_157: usize = 3;
+const OUT_157: usize = 3;
+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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_0, __v_1]; 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_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_149] = { let __args: [G; IN_149] = [__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[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_48: G = __r_arr[0];
+    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_49: G = __r_arr[0];
+    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_50: G = __r_arr[0];
+    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_51: G = __r_arr[0];
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_51, __v_2]; 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_52: G = __r_arr[0];
+    let __ret: [G; OUT_157] = [__v_52, __v_11, __v_12];
+    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);
+  })
+}
+
+const INPUT_SIZE_158: usize = 9;
+const IN_158: usize = 9;
+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 __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_149] = { let __args: [G; IN_149] = [__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[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_237] = { let __args: [G; IN_237] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+    let __v_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)); };
+    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 __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_151] = { let __args: [G; IN_151] = [__v_1, __v_4]; 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_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __ret: [G; OUT_159] = [__v_6];
+    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);
+  })
+}
+
+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 __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_160] = [__v_42];
+    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);
+  })
+}
+
+const INPUT_SIZE_161: usize = 2;
+const IN_161: usize = 2;
+const OUT_161: usize = 1;
+fn aiur_fn_161(
+  inp: [G; IN_161],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_161], 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 __ret: [G; OUT_161] = [__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);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_11, __v_1]; 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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_13: G = __r_arr[0];
+        let __ret: [G; OUT_161] = [__v_13];
+        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);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_162: usize = 2;
+const IN_162: usize = 2;
+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 __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_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)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        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);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_163: usize = 9;
+const IN_163: usize = 9;
+const OUT_163: usize = 9;
+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 __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_152] = { let __args: [G; IN_152] = [__v_6, __v_7]; 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_9: G = __r_arr[0];
+    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_3, __v_9]; 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_10: G = __r_arr[0];
+    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_2, __v_10]; 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_11: G = __r_arr[0];
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_1, __v_11]; 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_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __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 = 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_155] = { let __args: [G; IN_155] = [__v_55, __v_58]; 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_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_149] = { let __args: [G; IN_149] = [__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[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_80: G = __r_arr[0];
+    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_81: G = __r_arr[0];
+    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_75, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+    let __v_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_155] = { let __args: [G; IN_155] = [__v_82, __v_85]; 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_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_149] = { let __args: [G; IN_149] = [__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[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_107: G = __r_arr[0];
+    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_108: G = __r_arr[0];
+    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_102, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+    let __v_109: G = __r_arr[0];
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_109, __v_4]; 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 __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_119] = { let __args: [G; IN_119] = [__v_8, __v_113]; 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_114: G = __r_arr[0];
+    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_110, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+    let __v_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_155] = { let __args: [G; IN_155] = [__v_115, __v_118]; 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_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_159] = { let __args: [G; IN_159] = [__v_135, __v_5]; 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 __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_155] = { let __args: [G; IN_155] = [__v_137, __v_140]; 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_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_163] = [__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[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 = 3;
+const IN_164: usize = 3;
+const OUT_164: usize = 2;
+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];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_164] = [__v_0, __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 __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_164] = { let __args: [G; IN_164] = [__v_7, __v_10, __v_12]; 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_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __ret: [G; OUT_164] = [__v_13, __v_14];
+        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);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_165: usize = 1;
+const IN_165: usize = 1;
+const OUT_165: usize = 1;
+fn aiur_fn_165(
+  inp: [G; IN_165],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_165], 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_165] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      32u64 => {
+        let __v_1: G = G::from_u64(1753635133440165772);
+        let __ret: [G; OUT_165] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_1: G = G::from_u64(1);
+        let __v_2: G = (__v_0 + __v_1);
+        let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_2]; 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 __v_3: G = __r_arr[0];
+        let __v_4: G = (__v_3 * __v_3);
+        let __ret: [G; OUT_165] = [__v_4];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_166: usize = 3;
+const IN_166: usize = 3;
+const OUT_166: usize = 2;
+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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2]; 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_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_166] = [__v_7, __v_8];
+    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 = 1;
+const IN_167: usize = 1;
+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_167], 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_167] = [__v_1];
+        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)); };
+        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_167] = { let __args: [G; IN_167] = [__v_3]; 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_4: G = __r_arr[0];
+        let __v_5: G = (__v_1 * __v_4);
+        let __ret: [G; OUT_167] = [__v_5];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_168: usize = 3;
+const IN_168: usize = 3;
+const OUT_168: usize = 8;
+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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2]; 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_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_165] = { let __args: [G; IN_165] = [__v_2]; 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 __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_168] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94];
+    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 = 23;
+const IN_169: usize = 23;
+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 __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];
+    match __v_0.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_4]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        let __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_243] = { let __args: [G; IN_243] = [__v_21]; 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_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_243] = { let __args: [G; IN_243] = [__v_22]; 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_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_243] = { let __args: [G; IN_243] = [__v_18]; 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_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_148] = { let __args: [G; IN_148] = [__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_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_169] = [__v_31];
+        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);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_170: usize = 6;
+const IN_170: usize = 6;
+const OUT_170: usize = 2;
+fn aiur_fn_170(
+  inp: [G; IN_170],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_170], ExecError> {
+  stacker::maybe_grow(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_170] = [__v_14, __v_15];
+    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);
+  })
+}
+
+const INPUT_SIZE_171: usize = 4;
+const IN_171: usize = 4;
+const OUT_171: usize = 2;
+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 __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_171] = [__v_14, __v_15];
+    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);
+  })
+}
+
+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 __v_0: G = inp[0];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_172] = [__v_7];
+        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);
+      },
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_9: G = G::from_u64(0);
+            let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__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_10: G = __r_arr[0];
+            let __v_11: G = __r_arr[1];
+            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__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_12: G = __r_arr[0];
+            let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_172] = [__v_13];
+            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);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_173: usize = 15;
+const IN_173: usize = 15;
+const OUT_173: usize = 2;
+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 __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_241] = { let __args: [G; IN_241] = [__v_0, __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_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_173] = [__v_16, __v_19];
+        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);
+      },
+      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_233] = { let __args: [G; IN_233] = [__v_4, __v_18]; 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 __v_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_173] = [__v_21, __v_22];
+            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);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5, __v_18]; 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 __v_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_173] = [__v_21, __v_22];
+            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);
+          },
+          2u64 => {
+            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_18]; 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 __v_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_173] = [__v_21, __v_22];
+            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);
+          },
+          3u64 => {
+            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_18]; 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 __v_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_173] = [__v_21, __v_22];
+            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);
+          },
+          4u64 => {
+            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_6, __v_18]; 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 __v_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_173] = [__v_21, __v_22];
+            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);
+          },
+          _ => {
+            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_7, __v_18]; 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 __v_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_173] = [__v_21, __v_22];
+            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);
+          },
+        }
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_8, __v_16]; 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 __v_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __ret: [G; OUT_173] = [__v_19, __v_20];
+        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);
+      },
+      3u64 => {
+        let __ret: [G; OUT_173] = [__v_9, __v_10];
+        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);
+      },
+      4u64 => {
+        let __ret: [G; OUT_173] = [__v_11, __v_12];
+        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);
+      },
+      5u64 => {
+        let __ret: [G; OUT_173] = [__v_13, __v_14];
+        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);
+      },
+      6u64 => {
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[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_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_173] = [__v_23, __v_24];
+        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);
+      },
+      7u64 => {
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[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_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_173] = [__v_23, __v_24];
+        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);
+      },
+      8u64 => {
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[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_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_173] = [__v_27, __v_30];
+        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);
+      },
+      9u64 => {
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[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_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_173] = [__v_22, __v_24];
+        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);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_174: usize = 19;
+const IN_174: usize = 19;
+const OUT_174: usize = 2;
+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 __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() {
+      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 => {
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__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 __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__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_24: G = __r_arr[0];
+        let __v_25: G = __r_arr[1];
+        let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__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_26: G = __r_arr[0];
+        let __v_27: G = __r_arr[1];
+        let __ret: [G; OUT_174] = [__v_26, __v_27];
+        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);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_175: usize = 8;
+const IN_175: usize = 8;
+const OUT_175: usize = 4;
+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 __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_175] = [__v_50, __v_51, __v_52, __v_53];
+    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);
+  })
+}
+
+const INPUT_SIZE_176: usize = 19;
+const IN_176: usize = 19;
+const OUT_176: usize = 4;
+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 __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() {
+      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_176] = [__v_22, __v_23, __v_24, __v_25];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__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 __v_22: G = __r_arr[0];
+        let __v_23: G = __r_arr[1];
+        let __v_24: G = __r_arr[2];
+        let __v_25: G = __r_arr[3];
+        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__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 __v_26: G = __r_arr[0];
+        let __v_27: G = __r_arr[1];
+        let __v_28: G = __r_arr[2];
+        let __v_29: G = __r_arr[3];
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__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_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_176] = [__v_32, __v_33, __v_28, __v_29];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_177: usize = 44;
+const IN_177: usize = 44;
+const OUT_177: usize = 2;
+fn aiur_fn_177(
+  inp: [G; IN_177],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_177], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = 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_177] = [__v_0, __v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_45.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__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 __v_48: G = __r_arr[0];
+            let __v_49: G = __r_arr[1];
+            let __v_50: G = __r_arr[2];
+            let __v_51: G = __r_arr[3];
+            let __v_52: G = (__v_48 + __v_22);
+            let __v_53: G = (__v_49 + __v_23);
+            let __v_54: G = (__v_50 + __v_24);
+            let __v_55: G = (__v_51 + __v_25);
+            let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__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_56: G = __r_arr[0];
+            let __v_57: G = __r_arr[1];
+            let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__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 __v_58: G = __r_arr[0];
+            let __v_59: G = __r_arr[1];
+            let __v_60: G = __r_arr[2];
+            let __v_61: G = __r_arr[3];
+            let __v_62: G = (__v_56 * __v_10);
+            let __v_63: G = G::from_u64(7);
+            let __v_64: G = (__v_57 * __v_11);
+            let __v_65: G = (__v_63 * __v_64);
+            let __v_66: G = (__v_62 + __v_65);
+            let __v_67: G = (__v_56 * __v_11);
+            let __v_68: G = (__v_57 * __v_10);
+            let __v_69: G = (__v_67 + __v_68);
+            let __v_70: G = (__v_58 + __v_66);
+            let __v_71: G = (__v_59 + __v_69);
+            let __v_72: G = (__v_56 * __v_12);
+            let __v_73: G = G::from_u64(7);
+            let __v_74: G = (__v_57 * __v_13);
+            let __v_75: G = (__v_73 * __v_74);
+            let __v_76: G = (__v_72 + __v_75);
+            let __v_77: G = (__v_56 * __v_13);
+            let __v_78: G = (__v_57 * __v_12);
+            let __v_79: G = (__v_77 + __v_78);
+            let __v_80: G = (__v_60 + __v_76);
+            let __v_81: G = (__v_61 + __v_79);
+            let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__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 __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_233] = { let __args: [G; IN_233] = [__v_35, __v_89]; 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 __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_233] = { let __args: [G; IN_233] = [__v_35, __v_94]; 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 __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_233] = { let __args: [G; IN_233] = [__v_36, __v_97]; 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 __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_233] = { let __args: [G; IN_233] = [__v_36, __v_102]; 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 __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_175] = { let __args: [G; IN_175] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__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 __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_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__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_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_170] = { let __args: [G; IN_170] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__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_121: G = __r_arr[0];
+                let __v_122: G = __r_arr[1];
+                let __ret: [G; OUT_177] = [__v_121, __v_122];
+                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)); };
+                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_233] = { let __args: [G; IN_233] = [__v_35, __v_91]; 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 __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_233] = { let __args: [G; IN_233] = [__v_35, __v_96]; 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 __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_233] = { let __args: [G; IN_233] = [__v_35, __v_101]; 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 __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_233] = { let __args: [G; IN_233] = [__v_35, __v_106]; 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 __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_175] = { let __args: [G; IN_175] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__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 __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_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__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_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_170] = { let __args: [G; IN_170] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__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_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_177] = { let __args: [G; IN_177] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__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_137: G = __r_arr[0];
+                    let __v_138: G = __r_arr[1];
+                    let __ret: [G; OUT_177] = [__v_137, __v_138];
+                    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)); };
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_91: G = G::from_u64(1);
+                    let __v_92: G = (__v_5 + __v_91);
+                    let __v_93: G = G::from_u64(1);
+                    let __v_94: G = (__v_8 - __v_93);
+                    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__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_95: G = __r_arr[0];
+                    let __v_96: G = __r_arr[1];
+                    let __ret: [G; OUT_177] = [__v_95, __v_96];
+                    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)); };
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_178: usize = 28;
+const IN_178: usize = 28;
+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 __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_174] = { let __args: [G; IN_174] = [__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[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_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_233] = { let __args: [G; IN_233] = [__v_9, __v_82]; 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 __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_233] = { let __args: [G; IN_233] = [__v_8, __v_85]; 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 __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_170] = { let __args: [G; IN_170] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; 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_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_233] = { let __args: [G; IN_233] = [__v_9, __v_94]; 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 __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_233] = { let __args: [G; IN_233] = [__v_8, __v_97]; 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 __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_170] = { let __args: [G; IN_170] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; 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_104: G = __r_arr[0];
+        let __v_105: G = __r_arr[1];
+        let __ret: [G; OUT_178] = [__v_104, __v_105];
+        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);
+      },
+      0u64 => {
+        let __v_82: G = G::from_u64(0);
+        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_2]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+        let __v_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_177] = { let __args: [G; IN_177] = [__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[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_93: G = __r_arr[0];
+        let __v_94: G = __r_arr[1];
+        let __ret: [G; OUT_178] = [__v_93, __v_94];
+        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);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_78.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_179: usize = 8;
+const IN_179: usize = 8;
+const OUT_179: usize = 1;
+fn aiur_fn_179(
+  inp: [G; IN_179],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_179], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_27: G = { let __values: [G; 4] = [__v_22, __v_7, __v_23, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_28: G = { let __values: [G; 4] = [__v_20, __v_6, __v_21, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_29: G = { let __values: [G; 4] = [__v_18, __v_5, __v_19, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_30: G = { let __values: [G; 4] = [__v_16, __v_4, __v_17, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_31: G = { let __values: [G; 4] = [__v_14, __v_3, __v_15, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_179] = [__v_34];
+    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);
+  })
+}
+
+const INPUT_SIZE_180: usize = 5;
+const IN_180: usize = 5;
+const OUT_180: usize = 2;
+fn aiur_fn_180(
+  inp: [G; IN_180],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_180], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = 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() {
+      1u64 => {
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_180] = [__v_9, __v_10];
+        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 => {
+        let __v_9: G = (__v_3 * __v_6);
+        let __v_10: G = G::from_u64(7);
+        let __v_11: G = (__v_4 * __v_7);
+        let __v_12: G = (__v_10 * __v_11);
+        let __v_13: G = (__v_9 + __v_12);
+        let __v_14: G = (__v_3 * __v_7);
+        let __v_15: G = (__v_4 * __v_6);
+        let __v_16: G = (__v_14 + __v_15);
+        let __v_17: G = (__v_3 * __v_1);
+        let __v_18: G = G::from_u64(7);
+        let __v_19: G = (__v_4 * __v_2);
+        let __v_20: G = (__v_18 * __v_19);
+        let __v_21: G = (__v_17 + __v_20);
+        let __v_22: G = (__v_3 * __v_2);
+        let __v_23: G = (__v_4 * __v_1);
+        let __v_24: G = (__v_22 + __v_23);
+        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__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_25: G = __r_arr[0];
+        let __v_26: G = __r_arr[1];
+        let __v_27: G = (__v_13 + __v_25);
+        let __v_28: G = (__v_16 + __v_26);
+        let __ret: [G; OUT_180] = [__v_27, __v_28];
+        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);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_181], 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_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __v_1: G = G::from_u64(2);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      9u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      10u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      11u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      12u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      13u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      14u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      15u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      16u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      17u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_1: G = G::from_u64(32);
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_182: usize = 4;
+const IN_182: usize = 4;
+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 __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_182] = [__v_6, __v_9];
+        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);
+      },
+      1u64 => {
+        match __v_0.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = G::from_u64(1);
+            let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_182] = [__v_6, __v_9];
+            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);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_1, __v_3]; 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 __v_4: G = __r_arr[0];
+            let __v_5: G = G::from_u64(0);
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__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 __v_6: G = __r_arr[0];
+            let __v_7: G = G::from_u64(1);
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_7]; 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 __v_8: G = __r_arr[0];
+            let __ret: [G; OUT_182] = [__v_6, __v_8];
+            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);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_183: usize = 20;
+const IN_183: usize = 20;
+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_183], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+    let __v_20: G = __loaded[0];
+    let __v_21: G = __loaded[1];
+    let __v_22: G = __loaded[2];
+    let __v_23: G = __loaded[3];
+    let __v_24: G = __loaded[4];
+    let __v_25: G = __loaded[5];
+    let __v_26: G = __loaded[6];
+    let __v_27: G = __loaded[7];
+    match __v_20.as_canonical_u64() {
+      1u64 => {
+        let __v_28: G = G::from_u64(1);
+        let __ret: [G; OUT_183] = [__v_28];
+        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);
+      },
+      0u64 => {
+        match __v_21.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_2, __v_9]; 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 __v_28: G = __r_arr[0];
+            let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__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_29: G = __r_arr[0];
+            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_9]; 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 __v_30: G = __r_arr[0];
+            let __v_31: G = __r_arr[1];
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_9]; 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 __v_32: G = __r_arr[0];
+            let __v_33: G = G::from_u64(0);
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_32, __v_33]; 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 __v_34: G = __r_arr[0];
+            let __v_35: G = G::from_u64(1);
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_32, __v_35]; 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 __v_36: G = __r_arr[0];
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_9]; 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 __v_37: G = __r_arr[0];
+            let __v_38: G = G::from_u64(0);
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_37, __v_38]; 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 __v_39: G = __r_arr[0];
+            let __v_40: G = G::from_u64(1);
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_37, __v_40]; 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 __v_41: G = __r_arr[0];
+            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_9]; 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 __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_231] = { let __args: [G; IN_231] = [__v_7, __v_43]; 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 __v_44: G = __r_arr[0];
+        let __v_45: G = G::from_u64(0);
+        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_44, __v_45]; 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 __v_46: G = __r_arr[0];
+        let __v_47: G = G::from_u64(1);
+        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_44, __v_47]; 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 __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_164] = { let __args: [G; IN_164] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__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_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_165] = { let __args: [G; IN_165] = [__v_28]; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_167] = { let __args: [G; IN_167] = [__v_28]; 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_165: G = __r_arr[0];
+            let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__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 __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_174] = { let __args: [G; IN_174] = [__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[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_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_233] = { let __args: [G; IN_233] = [__v_41, __v_230]; 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 __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_233] = { let __args: [G; IN_233] = [__v_39, __v_233]; 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 __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_170] = { let __args: [G; IN_170] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; 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_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_233] = { let __args: [G; IN_233] = [__v_41, __v_242]; 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 __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_233] = { let __args: [G; IN_233] = [__v_39, __v_245]; 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 __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_170] = { let __args: [G; IN_170] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; 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_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_235] = { let __args: [G; IN_235] = [__v_25]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+    let __v_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_177] = { let __args: [G; IN_177] = [__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[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_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_231] = { let __args: [G; IN_231] = [__v_8, __v_9]; 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 __v_232: G = __r_arr[0];
+            let __v_233: G = G::from_u64(0);
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_232, __v_233]; 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 __v_234: G = __r_arr[0];
+            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_234]; 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_235: G = __r_arr[0];
+            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__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_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_180] = { let __args: [G; IN_180] = [__v_235, __v_236, __v_237, __v_238, __v_239]; 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_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_235] = { let __args: [G; IN_235] = [__v_235]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+            let __v_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_183] = { let __args: [G; IN_183] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_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[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 __v_265: G = __r_arr[0];
+            let __ret: [G; OUT_183] = [__v_265];
+            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);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_184], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    let __v_9: G = __loaded[6];
+    let __v_10: G = __loaded[7];
+    let __v_11: G = __loaded[8];
+    let __v_12: G = __loaded[9];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __v_13: G = G::from_u64(0);
+        let __v_14: G = G::from_u64(0);
+        let __ret: [G; OUT_184] = [__v_13, __v_14];
+        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_13: G = G::from_u64(256);
+        let __v_14: G = (__v_13 * __v_5);
+        let __v_15: G = G::from_u64(65536);
+        let __v_16: G = (__v_15 * __v_6);
+        let __v_17: G = G::from_u64(16777216);
+        let __v_18: G = (__v_17 * __v_7);
+        let __v_19: G = G::from_u64(4294967296);
+        let __v_20: G = (__v_19 * __v_8);
+        let __v_21: G = G::from_u64(1099511627776);
+        let __v_22: G = (__v_21 * __v_9);
+        let __v_23: G = G::from_u64(281474976710656);
+        let __v_24: G = (__v_23 * __v_10);
+        let __v_25: G = G::from_u64(72057594037927936);
+        let __v_26: G = (__v_25 * __v_11);
+        let __v_27: G = (__v_24 + __v_26);
+        let __v_28: G = (__v_22 + __v_27);
+        let __v_29: G = (__v_20 + __v_28);
+        let __v_30: G = (__v_18 + __v_29);
+        let __v_31: G = (__v_16 + __v_30);
+        let __v_32: G = (__v_14 + __v_31);
+        let __v_33: G = (__v_4 + __v_32);
+        let __v_34: G = G::from_u64(0);
+        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__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_35: G = __r_arr[0];
+        let __v_36: G = __r_arr[1];
+        let __v_37: G = (__v_0 * __v_35);
+        let __v_38: G = G::from_u64(7);
+        let __v_39: G = (__v_1 * __v_36);
+        let __v_40: G = (__v_38 * __v_39);
+        let __v_41: G = (__v_37 + __v_40);
+        let __v_42: G = (__v_0 * __v_36);
+        let __v_43: G = (__v_1 * __v_35);
+        let __v_44: G = (__v_42 + __v_43);
+        let __v_45: G = (__v_33 + __v_41);
+        let __v_46: G = (__v_34 + __v_44);
+        let __ret: [G; OUT_184] = [__v_45, __v_46];
+        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_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_185: usize = 7;
+const IN_185: usize = 7;
+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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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_185] = [__v_0, __v_1];
+        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);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__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_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_185] = { let __args: [G; IN_185] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__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_33: G = __r_arr[0];
+        let __v_34: G = __r_arr[1];
+        let __ret: [G; OUT_185] = [__v_33, __v_34];
+        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_7.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_186: usize = 37;
+const IN_186: usize = 37;
+const OUT_186: usize = 1;
+fn aiur_fn_186(
+  inp: [G; IN_186],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_186], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    match __v_0.as_canonical_u64() {
+      _ => {
+        match __v_0.as_canonical_u64() {
+          _ => {
+            match __v_12.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_8, __v_12]; 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_37: G = __r_arr[0];
+                let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_11, __v_12]; 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 __v_38: 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_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];
+  },
+  1u64 => {
+    break '__mc_0 [__v_10];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+  },
+}
+ };
+                    let __v_39: G = __mc_out___mc_0[0];
+                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_17, __v_36]; 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_40: G = __r_arr[0];
+                    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_13, __v_40]; 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_41: G = __r_arr[0];
+                    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_39, __v_41]; 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_42: G = __r_arr[0];
+                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_12, __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 __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_7, __v_43]; 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_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_155] = { let __args: [G; IN_155] = [__v_86, __v_89]; 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_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_149] = { let __args: [G; IN_149] = [__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[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_111: G = __r_arr[0];
+                    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_112: G = __r_arr[0];
+                    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_106, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+                    let __v_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_155] = { let __args: [G; IN_155] = [__v_113, __v_116]; 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_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_149] = { let __args: [G; IN_149] = [__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[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_138: G = __r_arr[0];
+                    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_139: G = __r_arr[0];
+                    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_133, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+                    let __v_140: G = __r_arr[0];
+                    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_140, __v_14]; 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 __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_119] = { let __args: [G; IN_119] = [__v_16, __v_144]; 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_145: G = __r_arr[0];
+                    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_141, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+                    let __v_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_155] = { let __args: [G; IN_155] = [__v_146, __v_149]; 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_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_159] = { let __args: [G; IN_159] = [__v_166, __v_15]; 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 __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_155] = { let __args: [G; IN_155] = [__v_168, __v_171]; 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_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_185] = { let __args: [G; IN_185] = [__v_358, __v_359, __v_35, __v_210, __v_231, __v_252, __v_273]; 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_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_183] = { let __args: [G; IN_183] = [__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[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 __v_363: G = __r_arr[0];
+                    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_37]; 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 __v_364: 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; 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_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() {
+  0u64 => {
+    break '__mc_1 [__v_368];
+  },
+  1u64 => {
+    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_32, __v_368]; 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_369: G = __r_arr[0];
+    break '__mc_1 [__v_369];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
+  },
+}
+ };
+                        let __v_369: G = __mc_out___mc_1[0];
+                        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_30, __v_369]; 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_370: G = __r_arr[0];
+                        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_34, __v_370]; 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_371: G = __r_arr[0];
+                        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_33, __v_371]; 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_372: G = __r_arr[0];
+                        let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_188, __v_372]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+                        let __v_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_155] = { let __args: [G; IN_155] = [__v_373, __v_376]; 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_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_125] = { let __args: [G; IN_125] = [__v_393, __v_18, __v_19, __v_5]; 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_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_119] = { let __args: [G; IN_119] = [__v_21, __v_441]; 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_442: G = __r_arr[0];
+                        let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_438, __v_442]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+                        let __v_443: G = __r_arr[0];
+                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_443, __v_18]; 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_444: G = __r_arr[0];
+                        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__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[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_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_187] = { let __args: [G; IN_187] = [__v_12]; 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 __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_243] = { let __args: [G; IN_243] = [__v_12]; 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_450: G = __r_arr[0];
+                        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; 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 __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_242] = { let __args: [G; IN_242] = [__v_37]; 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 __v_455: G = __r_arr[0];
+                        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_16]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+                        let __v_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_240] = { let __args: [G; IN_240] = [__v_19]; 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 __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_235] = { let __args: [G; IN_235] = [__v_20]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+                        let __v_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_235] = { let __args: [G; IN_235] = [__v_21]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+                        let __v_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 __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__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[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_473: G = __r_arr[0];
+                        let __ret: [G; OUT_186] = [__v_473];
+                        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);
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_187: usize = 1;
+const IN_187: usize = 1;
+const OUT_187: usize = 1;
+fn aiur_fn_187(
+  inp: [G; IN_187],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_187], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __ret: [G; OUT_187] = [__v_4];
+        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);
+      },
+      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_187] = { let __args: [G; IN_187] = [__v_3]; 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 __v_8: G = __r_arr[0];
+        let __ret: [G; OUT_187] = [__v_8];
+        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);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_188: usize = 2;
+const IN_188: usize = 2;
+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_188], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_188] = [__v_12];
+        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);
+      },
+      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_188] = { let __args: [G; IN_188] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__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_13: G = __r_arr[0];
+                let __ret: [G; OUT_188] = [__v_13];
+                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 __v_13: G = G::from_u64(0);
+                let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__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_14: G = __r_arr[0];
+                let __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_188] = [__v_15];
+                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);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_189: usize = 2;
+const IN_189: usize = 2;
+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_189], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_189] = [__v_8];
+        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)); };
+        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_189] = { let __args: [G; IN_189] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__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 __v_9: G = __r_arr[0];
+                let __ret: [G; OUT_189] = [__v_9];
+                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)); };
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_9: G = G::from_u64(0);
+                let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__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 __v_10: G = __r_arr[0];
+                let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_189] = [__v_11];
+                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)); };
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_190: usize = 1;
+const IN_190: usize = 1;
+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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; 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 __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_2, __v_1]; 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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_190] = [__v_3, __v_4];
+    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);
+  })
+}
+
+const INPUT_SIZE_191: usize = 2;
+const IN_191: usize = 2;
+const OUT_191: usize = 2;
+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 __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_191] = [__v_4, __v_0];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; 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 __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_3, __v_2]; 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 __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_191] = { let __args: [G; IN_191] = [__v_5, __v_7]; 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 __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_191] = [__v_11, __v_9];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_192: usize = 1;
+const IN_192: usize = 1;
+const OUT_192: usize = 2;
+fn aiur_fn_192(
+  inp: [G; IN_192],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_192], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; 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 __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_2, __v_1]; 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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_192] = [__v_3, __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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_193: usize = 2;
+const IN_193: usize = 2;
+const OUT_193: usize = 2;
+fn aiur_fn_193(
+  inp: [G; IN_193],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_193], 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; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_193] = [__v_4, __v_0];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; 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 __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_193] = { let __args: [G; IN_193] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__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 __v_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __v_15: G = G::from_u64(0);
+        let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_193] = [__v_16, __v_14];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_194: usize = 1;
+const IN_194: usize = 1;
+const OUT_194: usize = 2;
+fn aiur_fn_194(
+  inp: [G; IN_194],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_194], 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() {
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            match __v_7.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_10: G = __loaded[0];
+                let __v_11: G = __loaded[1];
+                let __v_12: G = __loaded[2];
+                match __v_10.as_canonical_u64() {
+                  0u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_13: G = __loaded[0];
+                    let __v_14: G = __loaded[1];
+                    let __v_15: G = __loaded[2];
+                    match __v_13.as_canonical_u64() {
+                      0u64 => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_16: G = __loaded[0];
+                        let __v_17: G = __loaded[1];
+                        let __v_18: G = __loaded[2];
+                        match __v_16.as_canonical_u64() {
+                          0u64 => {
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_19: G = __loaded[0];
+                            let __v_20: G = __loaded[1];
+                            let __v_21: G = __loaded[2];
+                            match __v_19.as_canonical_u64() {
+                              0u64 => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_22: G = __loaded[0];
+                                let __v_23: G = __loaded[1];
+                                let __v_24: G = __loaded[2];
+                                match __v_22.as_canonical_u64() {
+                                  0u64 => {
+                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                    let __v_25: G = __loaded[0];
+                                    let __v_26: G = __loaded[1];
+                                    let __v_27: G = __loaded[2];
+                                    match __v_25.as_canonical_u64() {
+                                      0u64 => {
+                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                        let __v_28: G = __loaded[0];
+                                        let __v_29: G = __loaded[1];
+                                        let __v_30: G = __loaded[2];
+                                        match __v_28.as_canonical_u64() {
+                                          0u64 => {
+                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                            let __v_31: G = __loaded[0];
+                                            let __v_32: G = __loaded[1];
+                                            let __v_33: G = __loaded[2];
+                                            match __v_31.as_canonical_u64() {
+                                              0u64 => {
+                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                let __v_34: G = __loaded[0];
+                                                let __v_35: G = __loaded[1];
+                                                let __v_36: G = __loaded[2];
+                                                match __v_34.as_canonical_u64() {
+                                                  0u64 => {
+                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                    let __v_37: G = __loaded[0];
+                                                    let __v_38: G = __loaded[1];
+                                                    let __v_39: G = __loaded[2];
+                                                    match __v_37.as_canonical_u64() {
+                                                      0u64 => {
+                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                        let __v_40: G = __loaded[0];
+                                                        let __v_41: G = __loaded[1];
+                                                        let __v_42: G = __loaded[2];
+                                                        match __v_40.as_canonical_u64() {
+                                                          0u64 => {
+                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                            let __v_43: G = __loaded[0];
+                                                            let __v_44: G = __loaded[1];
+                                                            let __v_45: G = __loaded[2];
+                                                            match __v_43.as_canonical_u64() {
+                                                              0u64 => {
+                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                let __v_46: G = __loaded[0];
+                                                                let __v_47: G = __loaded[1];
+                                                                let __v_48: G = __loaded[2];
+                                                                match __v_46.as_canonical_u64() {
+                                                                  0u64 => {
+                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                    let __v_49: G = __loaded[0];
+                                                                    let __v_50: G = __loaded[1];
+                                                                    let __v_51: G = __loaded[2];
+                                                                    match __v_49.as_canonical_u64() {
+                                                                      0u64 => {
+                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                        let __v_52: G = __loaded[0];
+                                                                        let __v_53: G = __loaded[1];
+                                                                        let __v_54: G = __loaded[2];
+                                                                        match __v_52.as_canonical_u64() {
+                                                                          0u64 => {
+                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                            let __v_55: G = __loaded[0];
+                                                                            let __v_56: G = __loaded[1];
+                                                                            let __v_57: G = __loaded[2];
+                                                                            match __v_55.as_canonical_u64() {
+                                                                              0u64 => {
+                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                let __v_58: G = __loaded[0];
+                                                                                let __v_59: G = __loaded[1];
+                                                                                let __v_60: G = __loaded[2];
+                                                                                match __v_58.as_canonical_u64() {
+                                                                                  0u64 => {
+                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                    let __v_61: G = __loaded[0];
+                                                                                    let __v_62: G = __loaded[1];
+                                                                                    let __v_63: G = __loaded[2];
+                                                                                    match __v_61.as_canonical_u64() {
+                                                                                      0u64 => {
+                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                        let __v_64: G = __loaded[0];
+                                                                                        let __v_65: G = __loaded[1];
+                                                                                        let __v_66: G = __loaded[2];
+                                                                                        match __v_64.as_canonical_u64() {
+                                                                                          0u64 => {
+                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                            let __v_67: G = __loaded[0];
+                                                                                            let __v_68: G = __loaded[1];
+                                                                                            let __v_69: G = __loaded[2];
+                                                                                            match __v_67.as_canonical_u64() {
+                                                                                              0u64 => {
+                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                let __v_70: G = __loaded[0];
+                                                                                                let __v_71: G = __loaded[1];
+                                                                                                let __v_72: G = __loaded[2];
+                                                                                                match __v_70.as_canonical_u64() {
+                                                                                                  0u64 => {
+                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                    let __v_73: G = __loaded[0];
+                                                                                                    let __v_74: G = __loaded[1];
+                                                                                                    let __v_75: G = __loaded[2];
+                                                                                                    match __v_73.as_canonical_u64() {
+                                                                                                      0u64 => {
+                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                        let __v_76: G = __loaded[0];
+                                                                                                        let __v_77: G = __loaded[1];
+                                                                                                        let __v_78: G = __loaded[2];
+                                                                                                        match __v_76.as_canonical_u64() {
+                                                                                                          0u64 => {
+                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                            let __v_79: G = __loaded[0];
+                                                                                                            let __v_80: G = __loaded[1];
+                                                                                                            let __v_81: G = __loaded[2];
+                                                                                                            match __v_79.as_canonical_u64() {
+                                                                                                              0u64 => {
+                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                let __v_82: G = __loaded[0];
+                                                                                                                let __v_83: G = __loaded[1];
+                                                                                                                let __v_84: G = __loaded[2];
+                                                                                                                match __v_82.as_canonical_u64() {
+                                                                                                                  0u64 => {
+                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                    let __v_85: G = __loaded[0];
+                                                                                                                    let __v_86: G = __loaded[1];
+                                                                                                                    let __v_87: G = __loaded[2];
+                                                                                                                    match __v_85.as_canonical_u64() {
+                                                                                                                      0u64 => {
+                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                        let __v_88: G = __loaded[0];
+                                                                                                                        let __v_89: G = __loaded[1];
+                                                                                                                        let __v_90: G = __loaded[2];
+                                                                                                                        match __v_88.as_canonical_u64() {
+                                                                                                                          0u64 => {
+                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                            let __v_91: G = __loaded[0];
+                                                                                                                            let __v_92: G = __loaded[1];
+                                                                                                                            let __v_93: G = __loaded[2];
+                                                                                                                            match __v_91.as_canonical_u64() {
+                                                                                                                              0u64 => {
+                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                let __v_94: G = __loaded[0];
+                                                                                                                                let __v_95: G = __loaded[1];
+                                                                                                                                let __v_96: G = __loaded[2];
+                                                                                                                                match __v_94.as_canonical_u64() {
+                                                                                                                                  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_194] = [__v_97, __v_96];
+                                                                                                                                    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)); };
+                                                                                                                                    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_195: usize = 2;
+const IN_195: usize = 2;
+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 __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 = __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_46: G = G::from_u64(0);
+    let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_48: G = G::from_u64(0);
+    let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_50: G = G::from_u64(0);
+    let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_52: G = G::from_u64(0);
+    let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_54: G = G::from_u64(0);
+    let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_56: G = G::from_u64(0);
+    let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_58: G = G::from_u64(0);
+    let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_60: G = G::from_u64(0);
+    let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_62: G = G::from_u64(0);
+    let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_64: G = G::from_u64(0);
+    let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_66: G = G::from_u64(0);
+    let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_68: G = G::from_u64(0);
+    let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_70: G = G::from_u64(0);
+    let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_72: G = G::from_u64(0);
+    let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_74: G = G::from_u64(0);
+    let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_76: G = G::from_u64(0);
+    let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_78: G = G::from_u64(0);
+    let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_80: G = G::from_u64(0);
+    let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_82: G = G::from_u64(0);
+    let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_84: G = G::from_u64(0);
+    let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_86: G = G::from_u64(0);
+    let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_88: G = G::from_u64(0);
+    let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_90: G = G::from_u64(0);
+    let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_92: G = G::from_u64(0);
+    let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_94: G = G::from_u64(0);
+    let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_96: G = G::from_u64(0);
+    let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_195] = [__v_97];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_196: usize = 1;
+const IN_196: usize = 1;
+const OUT_196: usize = 8;
+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 __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 __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_196] = [__v_41, __v_50, __v_59, __v_68, __v_77, __v_86, __v_95, __v_104];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_197: usize = 2;
+const IN_197: usize = 2;
+const OUT_197: usize = 1;
+fn aiur_fn_197(
+  inp: [G; IN_197],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_197], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(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_195] = { let __args: [G; IN_195] = [__v_1, __v_4]; 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_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_0, __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(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_65] = { let __args: [G; IN_65] = [__v_9]; 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_10: G = __r_arr[0];
+    let __ret: [G; OUT_197] = [__v_10];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_198: usize = 1;
+const IN_198: usize = 1;
+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 __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_195] = { let __args: [G; IN_195] = [__v_0, __v_3]; 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_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_65] = { let __args: [G; IN_65] = [__v_7]; 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_8: G = __r_arr[0];
+    let __ret: [G; OUT_198] = [__v_8];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_199: usize = 4;
+const IN_199: usize = 4;
+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 __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_199] = [__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)); };
+    return Ok(__ret);
+  })
+}
+
+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 __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 = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __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_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_200] = [__v_218];
+                                    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);
+                                  },
+                                  _ => {
+                                    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_200] = [__v_219];
+                                        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);
+                                      },
+                                      _ => {
+                                        let __v_219: G = G::from_u64(2);
+                                        let __ret: [G; OUT_200] = [__v_219];
+                                        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);
+                                      },
+                                    }
+                                  },
+                                }
+                              },
+                              _ => {
+                                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_200] = [__v_200];
+                                    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);
+                                  },
+                                  _ => {
+                                    let __v_200: G = G::from_u64(2);
+                                    let __ret: [G; OUT_200] = [__v_200];
+                                    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);
+                                  },
+                                }
+                              },
+                            }
+                          },
+                          _ => {
+                            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_200] = [__v_181];
+                                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);
+                              },
+                              _ => {
+                                let __v_181: G = G::from_u64(2);
+                                let __ret: [G; OUT_200] = [__v_181];
+                                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);
+                              },
+                            }
+                          },
+                        }
+                      },
+                      _ => {
+                        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_200] = [__v_162];
+                            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);
+                          },
+                          _ => {
+                            let __v_162: G = G::from_u64(2);
+                            let __ret: [G; OUT_200] = [__v_162];
+                            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);
+                          },
+                        }
+                      },
+                    }
+                  },
+                  _ => {
+                    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_200] = [__v_143];
+                        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);
+                      },
+                      _ => {
+                        let __v_143: G = G::from_u64(2);
+                        let __ret: [G; OUT_200] = [__v_143];
+                        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);
+                      },
+                    }
+                  },
+                }
+              },
+              _ => {
+                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_200] = [__v_124];
+                    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);
+                  },
+                  _ => {
+                    let __v_124: G = G::from_u64(2);
+                    let __ret: [G; OUT_200] = [__v_124];
+                    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);
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            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_200] = [__v_105];
+                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);
+              },
+              _ => {
+                let __v_105: G = G::from_u64(2);
+                let __ret: [G; OUT_200] = [__v_105];
+                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);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        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_200] = [__v_86];
+            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);
+          },
+          _ => {
+            let __v_86: G = G::from_u64(2);
+            let __ret: [G; OUT_200] = [__v_86];
+            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);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_201: usize = 1;
+const IN_201: usize = 1;
+const OUT_201: usize = 0;
+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 __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 __ret: [G; OUT_201] = [];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_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_201] = [];
+            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)); };
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_2, __v_5]; 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_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_201] = { let __args: [G; IN_201] = [__v_3]; 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 __ret: [G; OUT_201] = [];
+            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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.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 __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 __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_194] = { let __args: [G; IN_194] = [__v_2]; 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_9, __v_4];
+        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)); };
+        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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_5, __v_2];
+        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)); };
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__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_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_202] = [__v_7, __v_6];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_203: usize = 1;
+const IN_203: usize = 1;
+const OUT_203: usize = 1;
+fn aiur_fn_203(
+  inp: [G; IN_203],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_203], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(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_203] = [__v_6];
+        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 __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_7];
+        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);
+      },
+      _ => {
+        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(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_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);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_2, __v_39]; 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_41: G = __r_arr[0];
+            let __v_42: G = G::from_u64(1);
+            let __v_43: G = G::from_u64(1);
+            let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_45: G = { let __values: [G; 3] = [__v_40, __v_41, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_204] = [__v_45];
+            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 __v_7: G = G::from_u64(0);
+            let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_2, __v_5]; 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_8: G = __r_arr[0];
+            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_9: G = __r_arr[0];
+            let __v_10: G = { let __values: [G; 3] = [__v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_204] = [__v_10];
+            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_4.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_205: usize = 1;
+const IN_205: usize = 1;
+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_205], 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() {
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_205] = [__v_2];
+            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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0]; 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_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7]; 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_8: G = __r_arr[0];
+            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)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_206: usize = 1;
+const IN_206: usize = 1;
+const OUT_206: usize = 1;
+fn aiur_fn_206(
+  inp: [G; IN_206],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_206], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__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_1: G = __r_arr[0];
+    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__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 __ret: [G; OUT_206] = [__v_2];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_207: usize = 1;
+const IN_207: usize = 1;
+const OUT_207: usize = 1;
+fn aiur_fn_207(
+  inp: [G; IN_207],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_207], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = 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 __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_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 __v_37: G = __r_arr[0];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_37]; 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_38: G = __r_arr[0];
+    let __v_39: G = __r_arr[1];
+    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__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_40: G = __r_arr[0];
+    let __v_41: G = __r_arr[1];
+    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 __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_40]; 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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_44: G = __loaded[0];
+    let __v_45: G = __loaded[1];
+    let __v_46: G = __loaded[2];
+    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_232] = { let __args: [G; IN_232] = [__v_40]; 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 __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_1] = { let __args: [G; IN_1] = [__v_42, __v_0]; 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 __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_207] = [__v_40];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_208: usize = 2;
+const IN_208: usize = 2;
+const OUT_208: usize = 1;
+fn aiur_fn_208(
+  inp: [G; IN_208],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_208], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_4];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1]; 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 __v_2: G = __r_arr[0];
+        let __ret: [G; OUT_208] = [__v_2];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_209: usize = 2;
+const IN_209: usize = 2;
+const OUT_209: usize = 0;
+fn aiur_fn_209(
+  inp: [G; IN_209],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_209], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = 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];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_5: G = __loaded[0];
+    let __v_6: G = __loaded[1];
+    let __v_7: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_209] = [];
+            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)); };
+            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_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 __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_209] = { let __args: [G; IN_209] = [__v_4, __v_7]; 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 __ret: [G; OUT_209] = [];
+            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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_210: usize = 3;
+const IN_210: usize = 3;
+const OUT_210: usize = 0;
+fn aiur_fn_210(
+  inp: [G; IN_210],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_210], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    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_3.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_1, __v_2]; 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 __ret: [G; OUT_210] = [];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_0, __v_2]; 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 __ret: [G; OUT_210] = [];
+            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)); };
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_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_200] = { let __args: [G; IN_200] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__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_12: G = __r_arr[0];
+                match __v_12.as_canonical_u64() {
+                  0u64 => {
+                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __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 __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_210] = { let __args: [G; IN_210] = [__v_5, __v_1, __v_11]; 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 __ret: [G; OUT_210] = [];
+                    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)); };
+                    return Ok(__ret);
+                  },
+                  1u64 => {
+                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __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 __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_210] = { let __args: [G; IN_210] = [__v_5, __v_8, __v_11]; 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 __ret: [G; OUT_210] = [];
+                    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)); };
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    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 __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_210] = { let __args: [G; IN_210] = [__v_0, __v_8, __v_11]; 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 __ret: [G; OUT_210] = [];
+                    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)); };
+                    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_211: usize = 2;
+const IN_211: usize = 2;
+const OUT_211: usize = 4;
+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 __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];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_5: G = __loaded[0];
+    let __v_6: G = __loaded[1];
+    let __v_7: G = __loaded[2];
+    match __v_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_211] = [__v_8, __v_9, __v_9, __v_9];
+            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)); };
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_211] = [__v_8, __v_6, __v_0, __v_7];
+            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)); };
+            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_211] = [__v_8, __v_3, __v_4, __v_1];
+            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)); };
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__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];
+            match __v_8.as_canonical_u64() {
+              0u64 => {
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_211] = [__v_9, __v_3, __v_4, __v_1];
+                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)); };
+                return Ok(__ret);
+              },
+              1u64 => {
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_211] = [__v_9, __v_3, __v_4, __v_7];
+                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)); };
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_211] = [__v_9, __v_6, __v_0, __v_7];
+                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)); };
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_212: usize = 2;
+const IN_212: usize = 2;
+const OUT_212: usize = 2;
+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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_212] = [__v_5, __v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3, __v_0]; 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_5: G = __r_arr[0];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_4]; 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 __v_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __ret: [G; OUT_212] = [__v_6, __v_7];
+            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)); };
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __ret: [G; OUT_212] = [__v_6, __v_4];
+            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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_6: G = G::from_u64(0);
+            let __ret: [G; OUT_212] = [__v_6, __v_1];
+            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)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_213: usize = 4;
+const IN_213: usize = 4;
+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 __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_211] = { let __args: [G; IN_211] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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];
+        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_213] = [];
+        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)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_5, __v_2]; 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 __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_213] = { let __args: [G; IN_213] = [__v_6, __v_7, __v_9, __v_3]; 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 __ret: [G; OUT_213] = [];
+            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)); };
+            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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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 => {
+                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_5, __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 __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_213] = { let __args: [G; IN_213] = [__v_6, __v_7, __v_9, __v_12]; 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 __ret: [G; OUT_213] = [];
+                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)); };
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_214: usize = 3;
+const IN_214: usize = 3;
+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 __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_214] = [__v_0, __v_2];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; 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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__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];
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() {
+  0u64 => {
+    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_5, __v_0]; 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_7: G = __r_arr[0];
+    break '__mc_0 [__v_7];
+  },
+  _ => {
+    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0, __v_5]; 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_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_214] = { let __args: [G; IN_214] = [__v_7, __v_12, __v_6]; 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 __v_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __ret: [G; OUT_214] = [__v_13, __v_14];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_215: usize = 2;
+const IN_215: usize = 2;
+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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    let __v_9: G = __loaded[6];
+    let __v_10: G = __loaded[7];
+    let __v_11: G = __loaded[8];
+    let __v_12: G = __loaded[9];
+    let __v_13: G = __loaded[10];
+    let __v_14: G = __loaded[11];
+    let __v_15: G = __loaded[12];
+    let __v_16: G = __loaded[13];
+    let __v_17: G = __loaded[14];
+    let __v_18: G = __loaded[15];
+    let __v_19: G = __loaded[16];
+    let __v_20: G = __loaded[17];
+    let __v_21: G = __loaded[18];
+    let __v_22: G = __loaded[19];
+    let __v_23: G = __loaded[20];
+    let __v_24: G = __loaded[21];
+    let __v_25: G = __loaded[22];
+    let __v_26: G = __loaded[23];
+    let __v_27: G = __loaded[24];
+    let __v_28: G = __loaded[25];
+    let __v_29: G = __loaded[26];
+    let __v_30: G = __loaded[27];
+    let __v_31: G = __loaded[28];
+    let __v_32: G = __loaded[29];
+    let __v_33: G = __loaded[30];
+    let __v_34: G = __loaded[31];
+    let __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_2] = { let __args: [G; IN_2] = [__v_37, __v_35, __v_36]; 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 __v_38: G = __r_arr[0];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; 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_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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_44: G = __loaded[0];
+        let __v_45: G = __loaded[1];
+        let __v_46: G = __loaded[2];
+        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_215] = [__v_49];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        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 __v_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__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_46: G = __r_arr[0];
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_46, __v_44, __v_45]; 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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_52: G = __loaded[0];
+        let __v_53: G = __loaded[1];
+        let __v_54: G = __loaded[2];
+        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_1] = { let __args: [G; IN_1] = [__v_47, __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 __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_215] = [__v_59];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_216: usize = 4;
+const IN_216: usize = 4;
+const OUT_216: usize = 0;
+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 __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_211] = { let __args: [G; IN_211] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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];
+        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_216] = [];
+        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)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_5, __v_2]; 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 __v_8: G = __r_arr[0];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_6, __v_7, __v_2, __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 __ret: [G; OUT_216] = [];
+            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)); };
+            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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_5, __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 __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_216] = { let __args: [G; IN_216] = [__v_6, __v_7, __v_2, __v_11]; 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 __ret: [G; OUT_216] = [];
+                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)); };
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_217: usize = 1;
+const IN_217: usize = 1;
+const OUT_217: usize = 3;
+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 __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 __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_217] = [__v_3, __v_4, __v_2];
+        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)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_2]; 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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_217] = [__v_5, __v_3, __v_4];
+        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)); };
+        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 = 3;
+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 __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 __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_2]; 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_4]; 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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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];
+    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_218] = [__v_3, __v_5, __v_6];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_219: usize = 8;
+const IN_219: usize = 8;
+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 __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_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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_48: G = G::from_u64(0);
+    let __v_49: G = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_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_68] = { let __args: [G; IN_68] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; 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 __v_63: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_63]; 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 __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_219] = [__v_12];
+    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)); };
+    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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_1]; 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_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_220] = [__v_30];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_221: usize = 2;
+const IN_221: usize = 2;
+const OUT_221: usize = 8;
+fn aiur_fn_221(
+  inp: [G; IN_221],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_221], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0, __v_1]; 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 __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_220] = { let __args: [G; IN_220] = [__v_0, __v_4]; 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 __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_220] = { let __args: [G; IN_220] = [__v_0, __v_7]; 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 __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_220] = { let __args: [G; IN_220] = [__v_0, __v_10]; 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 __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_220] = { let __args: [G; IN_220] = [__v_0, __v_13]; 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 __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_220] = { let __args: [G; IN_220] = [__v_0, __v_16]; 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 __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_220] = { let __args: [G; IN_220] = [__v_0, __v_19]; 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 __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_220] = { let __args: [G; IN_220] = [__v_0, __v_22]; 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 __v_23: G = __r_arr[0];
+    let __ret: [G; OUT_221] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_222: usize = 16;
+const IN_222: usize = 16;
+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 __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_222] = [];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+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_223], 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() {
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        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_223] = [__v_2];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_224: usize = 17;
+const IN_224: usize = 17;
+const OUT_224: usize = 12;
+fn aiur_fn_224(
+  inp: [G; IN_224],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_224], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __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_2] = { let __args: [G; IN_2] = [__v_20, __v_18, __v_19]; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_57: G = G::from_u64(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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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; 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 __v_72: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; 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 __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_222] = { let __args: [G; IN_222] = [__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; 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)? } };
+    break '__mc_0 [];
+  },
+  _ => {
+    let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__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; 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)? } };
+    break '__mc_0 [];
+  },
+}
+ };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_21]; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_259: G = { let __values: [G; 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_260: G = { 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_246]; 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 __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; 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 __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; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_94(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } } else { aiur_fn_94(__args, record, io_buffer, __cu)? } };
+    let __v_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; 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_263, __v_331]; 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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } 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_224] = [__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 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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_225: usize = 13;
+const IN_225: usize = 13;
+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_225], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __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_29] = { let __args: [G; IN_29] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_16: G = __r_arr[0];
+    let __v_17: G = __r_arr[1];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_17, __v_16]; 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_18: G = __r_arr[0];
+    let __v_19: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19]; 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 __v_20: G = __r_arr[0];
+    let __v_21: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_21]; 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 __v_22: G = __r_arr[0];
+    let __v_23: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_23]; 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 __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 __v_26: G = __r_arr[0];
+    let __v_27: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_28: G = __r_arr[0];
+    let __v_29: G = __r_arr[1];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_29, __v_28]; 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_30: G = __r_arr[0];
+    let __v_31: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_32: G = __r_arr[0];
+    let __v_33: G = __r_arr[1];
+    let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_33, __v_32]; 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 __v_34: G = __r_arr[0];
+    let __v_35: G = __r_arr[1];
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_35]; 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_36: G = __r_arr[0];
+    let __v_37: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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, __v_38]; 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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_41]; 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_42: G = __r_arr[0];
+    let __v_43: G = __r_arr[1];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_43]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+    let __v_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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_52]; 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 __v_53: G = __r_arr[0];
+    let __v_54: G = __r_arr[1];
+    let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_54]; 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 __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_44] = { let __args: [G; IN_44] = [__v_57]; 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 __v_58: G = __r_arr[0];
+    let __v_59: G = __r_arr[1];
+    let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_59]; 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 __v_60: G = __r_arr[0];
+    let __v_61: G = __r_arr[1];
+    let __v_62: G = G::from_u64(2);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_12]; let __info = io_buffer.get_info(__v_62, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_63: G = __io_pair.0;
+    let __v_64: G = __io_pair.1;
+    let __v_65: G = G::from_u64(2);
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_65, __v_63, __v_64]; 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 __v_66: G = __r_arr[0];
+    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_66]; 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 __v_67: G = __r_arr[0];
+    let __v_68: G = __r_arr[1];
+    let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_68, __v_67]; 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 __v_69: G = __r_arr[0];
+    let __v_70: G = __r_arr[1];
+    match __v_18.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_26]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+        let __v_71: 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_188] = { let __args: [G; IN_188] = [__v_8, __v_18]; 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_72: G = __r_arr[0];
+                    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_11, __v_18]; 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 __v_73: 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_74: G = G::from_u64(1);
+    let __v_75: G = G::from_u64(1);
+    let __v_76: G = { let __values: [G; 3] = [__v_74, __v_75, __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 } };
+    break '__mc_0 [__v_76];
+  },
+  1u64 => {
+    break '__mc_0 [__v_10];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+  },
+}
+ };
+                        let __v_74: G = __mc_out___mc_0[0];
+                        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_30, __v_66]; 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_75: G = __r_arr[0];
+                        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_20, __v_75]; 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_76: G = __r_arr[0];
+                        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_74, __v_76]; 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_77: G = __r_arr[0];
+                        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_18, __v_77]; 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_78: G = __r_arr[0];
+                        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_7, __v_78]; 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_79: G = __r_arr[0];
+                        let __v_80: G = G::from_u64(0);
+                        let __v_81: G = G::from_u64(109);
+                        let __v_82: G = G::from_u64(0);
+                        let __v_83: G = G::from_u64(117);
+                        let __v_84: G = G::from_u64(0);
+                        let __v_85: G = G::from_u64(108);
+                        let __v_86: G = G::from_u64(0);
+                        let __v_87: G = G::from_u64(116);
+                        let __v_88: G = G::from_u64(0);
+                        let __v_89: G = G::from_u64(105);
+                        let __v_90: G = G::from_u64(0);
+                        let __v_91: G = G::from_u64(45);
+                        let __v_92: G = G::from_u64(0);
+                        let __v_93: G = G::from_u64(115);
+                        let __v_94: G = G::from_u64(0);
+                        let __v_95: G = G::from_u64(116);
+                        let __v_96: G = G::from_u64(0);
+                        let __v_97: G = G::from_u64(97);
+                        let __v_98: G = G::from_u64(0);
+                        let __v_99: G = G::from_u64(114);
+                        let __v_100: G = G::from_u64(0);
+                        let __v_101: G = G::from_u64(107);
+                        let __v_102: G = G::from_u64(0);
+                        let __v_103: G = G::from_u64(47);
+                        let __v_104: G = G::from_u64(0);
+                        let __v_105: G = G::from_u64(118);
+                        let __v_106: G = G::from_u64(0);
+                        let __v_107: G = G::from_u64(48);
+                        let __v_108: G = { let __values: [G; 3] = [__v_106, __v_107, __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_109: G = { let __values: [G; 3] = [__v_104, __v_105, __v_108]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_110: G = { let __values: [G; 3] = [__v_102, __v_103, __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 __v_111: G = { let __values: [G; 3] = [__v_100, __v_101, __v_110]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_112: G = { let __values: [G; 3] = [__v_98, __v_99, __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 __v_113: G = { let __values: [G; 3] = [__v_96, __v_97, __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 __v_114: G = { let __values: [G; 3] = [__v_94, __v_95, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_115: G = { let __values: [G; 3] = [__v_92, __v_93, __v_114]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_116: G = { let __values: [G; 3] = [__v_90, __v_91, __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 __v_117: G = { let __values: [G; 3] = [__v_88, __v_89, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_86, __v_87, __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 __v_119: G = { let __values: [G; 3] = [__v_84, __v_85, __v_118]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_120: G = { let __values: [G; 3] = [__v_82, __v_83, __v_119]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_121: G = { let __values: [G; 3] = [__v_80, __v_81, __v_120]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1);
+                        let __v_123: G = G::from_u64(1);
+                        let __v_124: G = { let __values: [G; 3] = [__v_122, __v_123, __v_123]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_121, __v_124]; 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_125: G = __r_arr[0];
+                        let __v_126: G = __r_arr[1];
+                        let __v_127: G = __r_arr[2];
+                        let __v_128: G = __r_arr[3];
+                        let __v_129: G = __r_arr[4];
+                        let __v_130: G = __r_arr[5];
+                        let __v_131: G = __r_arr[6];
+                        let __v_132: G = __r_arr[7];
+                        let __v_133: G = __r_arr[8];
+                        let __v_134: G = __r_arr[9];
+                        let __v_135: G = __r_arr[10];
+                        let __v_136: G = __r_arr[11];
+                        let __v_137: G = __r_arr[12];
+                        let __v_138: G = __r_arr[13];
+                        let __v_139: G = __r_arr[14];
+                        let __v_140: G = __r_arr[15];
+                        let __v_141: G = __r_arr[16];
+                        let __v_142: G = __r_arr[17];
+                        let __v_143: G = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_145]; 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_146: G = __r_arr[0];
+                        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_146]; 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_147: G = __r_arr[0];
+                        let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_141, __v_147]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+                        let __v_148: G = __r_arr[0];
+                        let __v_149: G = G::from_u64(1);
+                        let __v_150: G = G::from_u64(1);
+                        let __v_151: G = { let __values: [G; 3] = [__v_149, __v_150, __v_150]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_148, __v_151]; 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_152: G = __r_arr[0];
+                        let __v_153: G = __r_arr[1];
+                        let __v_154: G = __r_arr[2];
+                        let __v_155: G = __r_arr[3];
+                        let __v_156: G = __r_arr[4];
+                        let __v_157: G = __r_arr[5];
+                        let __v_158: G = __r_arr[6];
+                        let __v_159: G = __r_arr[7];
+                        let __v_160: G = __r_arr[8];
+                        let __v_161: G = __r_arr[9];
+                        let __v_162: G = __r_arr[10];
+                        let __v_163: G = __r_arr[11];
+                        let __v_164: G = __r_arr[12];
+                        let __v_165: G = __r_arr[13];
+                        let __v_166: G = __r_arr[14];
+                        let __v_167: G = __r_arr[15];
+                        let __v_168: G = __r_arr[16];
+                        let __v_169: G = __r_arr[17];
+                        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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_172]; 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_173: G = __r_arr[0];
+                        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_173]; 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_174: G = __r_arr[0];
+                        let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_168, __v_174]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+                        let __v_175: G = __r_arr[0];
+                        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_175, __v_22]; 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 __v_176: G = __r_arr[0];
+                        let __v_177: G = G::from_u64(1);
+                        let __v_178: G = G::from_u64(1);
+                        let __v_179: G = { let __values: [G; 3] = [__v_177, __v_178, __v_178]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_26, __v_179]; 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_180: G = __r_arr[0];
+                        let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_176, __v_180]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+                        let __v_181: G = __r_arr[0];
+                        let __v_182: G = G::from_u64(1);
+                        let __v_183: G = G::from_u64(1);
+                        let __v_184: G = { let __values: [G; 3] = [__v_182, __v_183, __v_183]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_181, __v_184]; 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_185: G = __r_arr[0];
+                        let __v_186: G = __r_arr[1];
+                        let __v_187: G = __r_arr[2];
+                        let __v_188: G = __r_arr[3];
+                        let __v_189: G = __r_arr[4];
+                        let __v_190: G = __r_arr[5];
+                        let __v_191: G = __r_arr[6];
+                        let __v_192: G = __r_arr[7];
+                        let __v_193: G = __r_arr[8];
+                        let __v_194: G = __r_arr[9];
+                        let __v_195: G = __r_arr[10];
+                        let __v_196: G = __r_arr[11];
+                        let __v_197: G = __r_arr[12];
+                        let __v_198: G = __r_arr[13];
+                        let __v_199: G = __r_arr[14];
+                        let __v_200: G = __r_arr[15];
+                        let __v_201: G = __r_arr[16];
+                        let __v_202: G = __r_arr[17];
+                        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_201, __v_24]; 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 __v_203: G = __r_arr[0];
+                        let __v_204: G = G::from_u64(1);
+                        let __v_205: G = G::from_u64(1);
+                        let __v_206: G = { let __values: [G; 3] = [__v_204, __v_205, __v_205]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_203, __v_206]; 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_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 __v_217: G = __r_arr[10];
+                        let __v_218: G = __r_arr[11];
+                        let __v_219: G = __r_arr[12];
+                        let __v_220: G = __r_arr[13];
+                        let __v_221: G = __r_arr[14];
+                        let __v_222: G = __r_arr[15];
+                        let __v_223: G = __r_arr[16];
+                        let __v_224: G = __r_arr[17];
+                        let __v_225: G = G::from_u64(256);
+                        let __v_226: G = (__v_225 * __v_126);
+                        let __v_227: G = G::from_u64(65536);
+                        let __v_228: G = (__v_227 * __v_127);
+                        let __v_229: G = G::from_u64(16777216);
+                        let __v_230: G = (__v_229 * __v_128);
+                        let __v_231: G = G::from_u64(4294967296);
+                        let __v_232: G = (__v_231 * __v_129);
+                        let __v_233: G = G::from_u64(1099511627776);
+                        let __v_234: G = (__v_233 * __v_130);
+                        let __v_235: G = G::from_u64(281474976710656);
+                        let __v_236: G = (__v_235 * __v_131);
+                        let __v_237: G = G::from_u64(72057594037927936);
+                        let __v_238: G = (__v_237 * __v_132);
+                        let __v_239: G = (__v_236 + __v_238);
+                        let __v_240: G = (__v_234 + __v_239);
+                        let __v_241: G = (__v_232 + __v_240);
+                        let __v_242: G = (__v_230 + __v_241);
+                        let __v_243: G = (__v_228 + __v_242);
+                        let __v_244: G = (__v_226 + __v_243);
+                        let __v_245: G = (__v_125 + __v_244);
+                        let __v_246: G = G::from_u64(256);
+                        let __v_247: G = (__v_246 * __v_134);
+                        let __v_248: G = G::from_u64(65536);
+                        let __v_249: G = (__v_248 * __v_135);
+                        let __v_250: G = G::from_u64(16777216);
+                        let __v_251: G = (__v_250 * __v_136);
+                        let __v_252: G = G::from_u64(4294967296);
+                        let __v_253: G = (__v_252 * __v_137);
+                        let __v_254: G = G::from_u64(1099511627776);
+                        let __v_255: G = (__v_254 * __v_138);
+                        let __v_256: G = G::from_u64(281474976710656);
+                        let __v_257: G = (__v_256 * __v_139);
+                        let __v_258: G = G::from_u64(72057594037927936);
+                        let __v_259: G = (__v_258 * __v_140);
+                        let __v_260: G = (__v_257 + __v_259);
+                        let __v_261: G = (__v_255 + __v_260);
+                        let __v_262: G = (__v_253 + __v_261);
+                        let __v_263: G = (__v_251 + __v_262);
+                        let __v_264: G = (__v_249 + __v_263);
+                        let __v_265: G = (__v_247 + __v_264);
+                        let __v_266: G = (__v_133 + __v_265);
+                        let __v_267: G = G::from_u64(256);
+                        let __v_268: G = (__v_267 * __v_153);
+                        let __v_269: G = G::from_u64(65536);
+                        let __v_270: G = (__v_269 * __v_154);
+                        let __v_271: G = G::from_u64(16777216);
+                        let __v_272: G = (__v_271 * __v_155);
+                        let __v_273: G = G::from_u64(4294967296);
+                        let __v_274: G = (__v_273 * __v_156);
+                        let __v_275: G = G::from_u64(1099511627776);
+                        let __v_276: G = (__v_275 * __v_157);
+                        let __v_277: G = G::from_u64(281474976710656);
+                        let __v_278: G = (__v_277 * __v_158);
+                        let __v_279: G = G::from_u64(72057594037927936);
+                        let __v_280: G = (__v_279 * __v_159);
+                        let __v_281: G = (__v_278 + __v_280);
+                        let __v_282: G = (__v_276 + __v_281);
+                        let __v_283: G = (__v_274 + __v_282);
+                        let __v_284: G = (__v_272 + __v_283);
+                        let __v_285: G = (__v_270 + __v_284);
+                        let __v_286: G = (__v_268 + __v_285);
+                        let __v_287: G = (__v_152 + __v_286);
+                        let __v_288: G = G::from_u64(256);
+                        let __v_289: G = (__v_288 * __v_161);
+                        let __v_290: G = G::from_u64(65536);
+                        let __v_291: G = (__v_290 * __v_162);
+                        let __v_292: G = G::from_u64(16777216);
+                        let __v_293: G = (__v_292 * __v_163);
+                        let __v_294: G = G::from_u64(4294967296);
+                        let __v_295: G = (__v_294 * __v_164);
+                        let __v_296: G = G::from_u64(1099511627776);
+                        let __v_297: G = (__v_296 * __v_165);
+                        let __v_298: G = G::from_u64(281474976710656);
+                        let __v_299: G = (__v_298 * __v_166);
+                        let __v_300: G = G::from_u64(72057594037927936);
+                        let __v_301: G = (__v_300 * __v_167);
+                        let __v_302: G = (__v_299 + __v_301);
+                        let __v_303: G = (__v_297 + __v_302);
+                        let __v_304: G = (__v_295 + __v_303);
+                        let __v_305: G = (__v_293 + __v_304);
+                        let __v_306: G = (__v_291 + __v_305);
+                        let __v_307: G = (__v_289 + __v_306);
+                        let __v_308: G = (__v_160 + __v_307);
+                        let __v_309: G = G::from_u64(256);
+                        let __v_310: G = (__v_309 * __v_186);
+                        let __v_311: G = G::from_u64(65536);
+                        let __v_312: G = (__v_311 * __v_187);
+                        let __v_313: G = G::from_u64(16777216);
+                        let __v_314: G = (__v_313 * __v_188);
+                        let __v_315: G = G::from_u64(4294967296);
+                        let __v_316: G = (__v_315 * __v_189);
+                        let __v_317: G = G::from_u64(1099511627776);
+                        let __v_318: G = (__v_317 * __v_190);
+                        let __v_319: G = G::from_u64(281474976710656);
+                        let __v_320: G = (__v_319 * __v_191);
+                        let __v_321: G = G::from_u64(72057594037927936);
+                        let __v_322: G = (__v_321 * __v_192);
+                        let __v_323: G = (__v_320 + __v_322);
+                        let __v_324: G = (__v_318 + __v_323);
+                        let __v_325: G = (__v_316 + __v_324);
+                        let __v_326: G = (__v_314 + __v_325);
+                        let __v_327: G = (__v_312 + __v_326);
+                        let __v_328: G = (__v_310 + __v_327);
+                        let __v_329: G = (__v_185 + __v_328);
+                        let __v_330: G = G::from_u64(256);
+                        let __v_331: G = (__v_330 * __v_194);
+                        let __v_332: G = G::from_u64(65536);
+                        let __v_333: G = (__v_332 * __v_195);
+                        let __v_334: G = G::from_u64(16777216);
+                        let __v_335: G = (__v_334 * __v_196);
+                        let __v_336: G = G::from_u64(4294967296);
+                        let __v_337: G = (__v_336 * __v_197);
+                        let __v_338: G = G::from_u64(1099511627776);
+                        let __v_339: G = (__v_338 * __v_198);
+                        let __v_340: G = G::from_u64(281474976710656);
+                        let __v_341: G = (__v_340 * __v_199);
+                        let __v_342: G = G::from_u64(72057594037927936);
+                        let __v_343: G = (__v_342 * __v_200);
+                        let __v_344: G = (__v_341 + __v_343);
+                        let __v_345: G = (__v_339 + __v_344);
+                        let __v_346: G = (__v_337 + __v_345);
+                        let __v_347: G = (__v_335 + __v_346);
+                        let __v_348: G = (__v_333 + __v_347);
+                        let __v_349: G = (__v_331 + __v_348);
+                        let __v_350: G = (__v_193 + __v_349);
+                        let __v_351: G = G::from_u64(256);
+                        let __v_352: G = (__v_351 * __v_208);
+                        let __v_353: G = G::from_u64(65536);
+                        let __v_354: G = (__v_353 * __v_209);
+                        let __v_355: G = G::from_u64(16777216);
+                        let __v_356: G = (__v_355 * __v_210);
+                        let __v_357: G = G::from_u64(4294967296);
+                        let __v_358: G = (__v_357 * __v_211);
+                        let __v_359: G = G::from_u64(1099511627776);
+                        let __v_360: G = (__v_359 * __v_212);
+                        let __v_361: G = G::from_u64(281474976710656);
+                        let __v_362: G = (__v_361 * __v_213);
+                        let __v_363: G = G::from_u64(72057594037927936);
+                        let __v_364: G = (__v_363 * __v_214);
+                        let __v_365: G = (__v_362 + __v_364);
+                        let __v_366: G = (__v_360 + __v_365);
+                        let __v_367: G = (__v_358 + __v_366);
+                        let __v_368: G = (__v_356 + __v_367);
+                        let __v_369: G = (__v_354 + __v_368);
+                        let __v_370: G = (__v_352 + __v_369);
+                        let __v_371: G = (__v_207 + __v_370);
+                        let __v_372: G = G::from_u64(256);
+                        let __v_373: G = (__v_372 * __v_216);
+                        let __v_374: G = G::from_u64(65536);
+                        let __v_375: G = (__v_374 * __v_217);
+                        let __v_376: G = G::from_u64(16777216);
+                        let __v_377: G = (__v_376 * __v_218);
+                        let __v_378: G = G::from_u64(4294967296);
+                        let __v_379: G = (__v_378 * __v_219);
+                        let __v_380: G = G::from_u64(1099511627776);
+                        let __v_381: G = (__v_380 * __v_220);
+                        let __v_382: G = G::from_u64(281474976710656);
+                        let __v_383: G = (__v_382 * __v_221);
+                        let __v_384: G = G::from_u64(72057594037927936);
+                        let __v_385: G = (__v_384 * __v_222);
+                        let __v_386: G = (__v_383 + __v_385);
+                        let __v_387: G = (__v_381 + __v_386);
+                        let __v_388: G = (__v_379 + __v_387);
+                        let __v_389: G = (__v_377 + __v_388);
+                        let __v_390: G = (__v_375 + __v_389);
+                        let __v_391: G = (__v_373 + __v_390);
+                        let __v_392: G = (__v_215 + __v_391);
+                        let __v_393: G = G::from_u64(0);
+                        let __v_394: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_393, __v_394, __v_69, __v_245, __v_266, __v_287, __v_308]; 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_395: G = __r_arr[0];
+                        let __v_396: G = __r_arr[1];
+                        let __v_397: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_72, __v_73, __v_30, __v_26, __v_58, __v_60, __v_55, __v_56, __v_53, __v_397, __v_395, __v_396, __v_245, __v_266, __v_287, __v_308, __v_329, __v_350, __v_371, __v_392]; 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 __v_398: G = __r_arr[0];
+                        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_72]; 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 __v_399: 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; 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_400: G = __r_arr[0];
+                            let __v_401: G = G::from_u64(1);
+                            let __v_402: G = G::from_u64(1);
+                            let __v_403: G = { let __values: [G; 3] = [__v_401, __v_402, __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 __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_55.as_canonical_u64() {
+  0u64 => {
+    break '__mc_1 [__v_403];
+  },
+  1u64 => {
+    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_56, __v_403]; 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_404: G = __r_arr[0];
+    break '__mc_1 [__v_404];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64()));
+  },
+}
+ };
+                            let __v_404: G = __mc_out___mc_1[0];
+                            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_53, __v_404]; 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_405: G = __r_arr[0];
+                            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_60, __v_405]; 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_406: G = __r_arr[0];
+                            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_58, __v_406]; 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_407: G = __r_arr[0];
+                            let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_223, __v_407]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+                            let __v_408: G = __r_arr[0];
+                            let __v_409: G = G::from_u64(1);
+                            let __v_410: G = G::from_u64(1);
+                            let __v_411: G = { let __values: [G; 3] = [__v_409, __v_410, __v_410]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_408, __v_411]; 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_412: G = __r_arr[0];
+                            let __v_413: G = __r_arr[1];
+                            let __v_414: G = __r_arr[2];
+                            let __v_415: G = __r_arr[3];
+                            let __v_416: G = __r_arr[4];
+                            let __v_417: G = __r_arr[5];
+                            let __v_418: G = __r_arr[6];
+                            let __v_419: G = __r_arr[7];
+                            let __v_420: G = __r_arr[8];
+                            let __v_421: G = __r_arr[9];
+                            let __v_422: G = __r_arr[10];
+                            let __v_423: G = __r_arr[11];
+                            let __v_424: G = __r_arr[12];
+                            let __v_425: G = __r_arr[13];
+                            let __v_426: G = __r_arr[14];
+                            let __v_427: G = __r_arr[15];
+                            let __v_428: G = __r_arr[16];
+                            let __v_429: G = __r_arr[17];
+                            let __v_430: G = G::from_u64(256);
+                            let __v_431: G = (__v_430 * __v_413);
+                            let __v_432: G = G::from_u64(65536);
+                            let __v_433: G = (__v_432 * __v_414);
+                            let __v_434: G = G::from_u64(16777216);
+                            let __v_435: G = (__v_434 * __v_415);
+                            let __v_436: G = G::from_u64(4294967296);
+                            let __v_437: G = (__v_436 * __v_416);
+                            let __v_438: G = G::from_u64(1099511627776);
+                            let __v_439: G = (__v_438 * __v_417);
+                            let __v_440: G = G::from_u64(281474976710656);
+                            let __v_441: G = (__v_440 * __v_418);
+                            let __v_442: G = G::from_u64(72057594037927936);
+                            let __v_443: G = (__v_442 * __v_419);
+                            let __v_444: G = (__v_441 + __v_443);
+                            let __v_445: G = (__v_439 + __v_444);
+                            let __v_446: G = (__v_437 + __v_445);
+                            let __v_447: G = (__v_435 + __v_446);
+                            let __v_448: G = (__v_433 + __v_447);
+                            let __v_449: G = (__v_431 + __v_448);
+                            let __v_450: G = (__v_412 + __v_449);
+                            let __v_451: G = G::from_u64(256);
+                            let __v_452: G = (__v_451 * __v_421);
+                            let __v_453: G = G::from_u64(65536);
+                            let __v_454: G = (__v_453 * __v_422);
+                            let __v_455: G = G::from_u64(16777216);
+                            let __v_456: G = (__v_455 * __v_423);
+                            let __v_457: G = G::from_u64(4294967296);
+                            let __v_458: G = (__v_457 * __v_424);
+                            let __v_459: G = G::from_u64(1099511627776);
+                            let __v_460: G = (__v_459 * __v_425);
+                            let __v_461: G = G::from_u64(281474976710656);
+                            let __v_462: G = (__v_461 * __v_426);
+                            let __v_463: G = G::from_u64(72057594037927936);
+                            let __v_464: G = (__v_463 * __v_427);
+                            let __v_465: G = (__v_462 + __v_464);
+                            let __v_466: G = (__v_460 + __v_465);
+                            let __v_467: G = (__v_458 + __v_466);
+                            let __v_468: G = (__v_456 + __v_467);
+                            let __v_469: G = (__v_454 + __v_468);
+                            let __v_470: G = (__v_452 + __v_469);
+                            let __v_471: G = (__v_420 + __v_470);
+                            let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_428, __v_34, __v_36, __v_5]; 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_472: G = __r_arr[0];
+                            let __v_473: G = __r_arr[1];
+                            let __v_474: G = G::from_u64(1);
+                            let __v_475: G = G::from_u64(1);
+                            let __v_476: G = { let __values: [G; 3] = [__v_474, __v_475, __v_475]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_42, __v_476]; 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_477: G = __r_arr[0];
+                            let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_473, __v_477]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+                            let __v_478: G = __r_arr[0];
+                            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_478, __v_34]; 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_479: G = __r_arr[0];
+                            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_479, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_6]; 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_480: G = __r_arr[0];
+                            let __v_481: G = __r_arr[1];
+                            let __v_482: G = (__v_400 + __v_0);
+                            let __v_483: G = (__v_14 + __v_15);
+                            if (__v_61 != __v_483) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_483.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_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: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_484: G = __loaded[0];
+                            let __v_485: G = __loaded[1];
+                            let __v_486: G = __loaded[2];
+                            let __v_487: G = G::from_u64(1);
+                            let __v_488: G = G::from_u64(1);
+                            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_488) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_485.as_canonical_u64(), rhs: __v_488.as_canonical_u64(), msg: None });
+                            }
+                            if (__v_486 != __v_488) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_486.as_canonical_u64(), rhs: __v_488.as_canonical_u64(), msg: None });
+                            }
+                            let __v_489: G = G::from_bool((__v_71 == G::ZERO));
+                            let __v_490: G = G::from_u64(0);
+                            if (__v_489 != __v_490) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_489.as_canonical_u64(), rhs: __v_490.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_58]; 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_491: G = __r_arr[0];
+                            if (__v_491 != __v_71) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_491.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_60]; 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_492: G = __r_arr[0];
+                            if (__v_492 != __v_71) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_492.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_53]; 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_493: G = __r_arr[0];
+                            if (__v_493 != __v_71) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_493.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_26]; 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_494: G = __r_arr[0];
+                            let __v_495: G = G::from_u64(1);
+                            if (__v_494 != __v_495) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_494.as_canonical_u64(), rhs: __v_495.as_canonical_u64(), msg: None });
+                            }
+                            let __v_496: G = G::from_u64(1);
+                            let __v_497: G = G::from_u64(1);
+                            if (__v_496 != __v_497) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_496.as_canonical_u64(), rhs: __v_497.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_18]; 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 __v_498: G = __r_arr[0];
+                            let __v_499: G = G::from_u64(1);
+                            if (__v_498 != __v_499) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_498.as_canonical_u64(), rhs: __v_499.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_18]; 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_500: G = __r_arr[0];
+                            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; 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 __v_501: G = __r_arr[0];
+                            let __v_502: G = (__v_500 - __v_501);
+                            let __v_503: G = G::from_bool((__v_502 == G::ZERO));
+                            let __v_504: G = G::from_u64(1);
+                            if (__v_503 != __v_504) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_503.as_canonical_u64(), rhs: __v_504.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_72]; 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 __v_505: G = __r_arr[0];
+                            let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_26]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+                            let __v_506: G = __r_arr[0];
+                            let __v_507: G = (__v_505 - __v_506);
+                            let __v_508: G = G::from_bool((__v_507 == G::ZERO));
+                            let __v_509: G = G::from_u64(1);
+                            if (__v_508 != __v_509) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_508.as_canonical_u64(), rhs: __v_509.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_36]; 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 __v_510: G = __r_arr[0];
+                            let __v_511: G = (__v_510 - __v_400);
+                            let __v_512: G = G::from_bool((__v_511 == G::ZERO));
+                            let __v_513: G = G::from_u64(1);
+                            if (__v_512 != __v_513) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_513.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_40]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+                            let __v_514: G = __r_arr[0];
+                            let __v_515: G = (__v_514 - __v_4);
+                            let __v_516: G = G::from_bool((__v_515 == G::ZERO));
+                            let __v_517: G = G::from_u64(1);
+                            if (__v_516 != __v_517) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_516.as_canonical_u64(), rhs: __v_517.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_42]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+                            let __v_518: G = __r_arr[0];
+                            let __v_519: G = G::from_u64(1);
+                            if (__v_518 != __v_519) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_518.as_canonical_u64(), rhs: __v_519.as_canonical_u64(), msg: None });
+                            }
+                            let __v_520: G = G::from_u64(33);
+                            let __v_521: G = { let __a_val = __v_482.as_canonical_u64(); let __b_val = __v_520.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_522: G = G::from_u64(1);
+                            if (__v_521 != __v_522) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_521.as_canonical_u64(), rhs: __v_522.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_480, __v_481, __v_40, __v_450, __v_471, __v_58, __v_60, __v_53, __v_55, __v_56, __v_20, __v_22, __v_24, __v_74, __v_73, __v_30, __v_371, __v_392, __v_399, __v_0, __v_482, __v_472, __v_34, __v_42, __v_400]; 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_523: G = __r_arr[0];
+                            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 __ret: [G; OUT_225] = [__v_69];
+                            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)); };
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_226: usize = 28;
+const IN_226: usize = 28;
+const OUT_226: usize = 8;
+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 __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_224] = { let __args: [G; IN_224] = [__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; 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 __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_225] = { let __args: [G; IN_225] = [__v_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; 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_40: G = __r_arr[0];
+    let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_40]; 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 __v_41: G = __r_arr[0];
+    let __v_42: G = G::from_u64(0);
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_41, __v_42]; 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 __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_240] = { let __args: [G; IN_240] = [__v_41]; 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 __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_220] = { let __args: [G; IN_220] = [__v_41, __v_47]; 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 __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_221] = { let __args: [G; IN_221] = [__v_41, __v_49]; 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 __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_226] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_45: G = G::from_u64(2);
+        let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_41, __v_45]; 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 __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_222] = { let __args: [G; IN_222] = [__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; 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_240] = { let __args: [G; IN_240] = [__v_41]; 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 __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_220] = { let __args: [G; IN_220] = [__v_41, __v_56]; 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 __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_221] = { let __args: [G; IN_221] = [__v_41, __v_58]; 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 __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_226] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_227: usize = 35;
+const IN_227: usize = 35;
+const OUT_227: usize = 0;
+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 __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_226] = { let __args: [G; IN_226] = [__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; 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 __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_222] = { let __args: [G; IN_222] = [__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; 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 __ret: [G; OUT_227] = [];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_228: usize = 36;
+const IN_228: usize = 36;
+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 __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_226] = { let __args: [G; IN_226] = [__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; 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 __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_226] = { let __args: [G; IN_226] = [__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; 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 __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_219] = { let __args: [G; IN_219] = [__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[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 __v_54: G = __r_arr[0];
+    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_54]; 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 __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_219] = { let __args: [G; IN_219] = [__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[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 __v_58: G = __r_arr[0];
+    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_58]; 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 __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_2] = { let __args: [G; IN_2] = [__v_66, __v_64, __v_65]; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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; 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 __v_118: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_118]; 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 __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_218] = { let __args: [G; IN_218] = [__v_67]; 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 __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_207] = { let __args: [G; IN_207] = [__v_55]; 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 __v_154: G = __r_arr[0];
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_59]; 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 __v_155: G = __r_arr[0];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_56, __v_57]; 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 __v_156: G = __r_arr[0];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_60, __v_61]; 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 __v_157: G = __r_arr[0];
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_151]; 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 __v_158: G = __r_arr[0];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_152, __v_153]; 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 __v_159: G = __r_arr[0];
+    let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_154, __v_155, __v_158]; 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_213] = { let __args: [G; IN_213] = [__v_156, __v_157, __v_158, __v_159]; 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 __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_228] = [];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_229: usize = 36;
+const IN_229: usize = 36;
+const OUT_229: usize = 0;
+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 __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_226] = { let __args: [G; IN_226] = [__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; 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 __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_226] = { let __args: [G; IN_226] = [__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; 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 __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_219] = { let __args: [G; IN_219] = [__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[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 __v_54: G = __r_arr[0];
+    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_54]; 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 __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_219] = { let __args: [G; IN_219] = [__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[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 __v_58: G = __r_arr[0];
+    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_58]; 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 __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_2] = { let __args: [G; IN_2] = [__v_66, __v_64, __v_65]; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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; 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 __v_118: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_118]; 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 __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_218] = { let __args: [G; IN_218] = [__v_67]; 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 __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_197] = { let __args: [G; IN_197] = [__v_55, __v_59]; 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_154: G = __r_arr[0];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_56, __v_57]; 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 __v_155: G = __r_arr[0];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_60, __v_61]; 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 __v_156: G = __r_arr[0];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_152, __v_153]; 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 __v_157: G = __r_arr[0];
+    let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_155, __v_156, __v_151, __v_157]; 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 __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_1] = { let __args: [G; IN_1] = [__v_151, __v_154]; 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 __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_229] = [];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_230: usize = 16;
+const IN_230: usize = 16;
+const OUT_230: usize = 0;
+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 __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_2] = { let __args: [G; IN_2] = [__v_20, __v_18, __v_19]; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_57: G = G::from_u64(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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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; 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 __v_72: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; 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 __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_194] = { let __args: [G; IN_194] = [__v_21]; 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_105: G = __r_arr[0];
+    let __v_106: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_106]; 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_107: G = __r_arr[0];
+    let __v_108: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_108]; 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_109: G = __r_arr[0];
+    let __v_110: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_110]; 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_111: G = __r_arr[0];
+    let __v_112: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_112]; 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_113: G = __r_arr[0];
+    let __v_114: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_114]; 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_115: G = __r_arr[0];
+    let __v_116: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_116]; 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_117: G = __r_arr[0];
+    let __v_118: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_118]; 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_119: G = __r_arr[0];
+    let __v_120: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_120]; 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_121: G = __r_arr[0];
+    let __v_122: G = __r_arr[1];
+    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_122]; 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_123: G = __r_arr[0];
+    let __v_124: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_124]; 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_125: G = __r_arr[0];
+    let __v_126: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_126]; 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_127: G = __r_arr[0];
+    let __v_128: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_128]; 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_129: G = __r_arr[0];
+    let __v_130: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_130]; 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_131: G = __r_arr[0];
+    let __v_132: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_132]; 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_133: G = __r_arr[0];
+    let __v_134: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_134]; 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_135: G = __r_arr[0];
+    let __v_136: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_136]; 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_137: G = __r_arr[0];
+    let __v_138: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_138]; 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_139: G = __r_arr[0];
+    let __v_140: G = __r_arr[1];
+    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_105]; 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_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_196] = { let __args: [G; IN_196] = [__v_123]; 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_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_12] = { let __args: [G; IN_12] = [__v_107, __v_109, __v_111, __v_113, __v_115, __v_117, __v_119, __v_121]; 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 __v_157: G = __r_arr[0];
+    let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_125, __v_127, __v_129, __v_131, __v_133, __v_135, __v_137, __v_139]; 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 __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_2] = { let __args: [G; IN_2] = [__v_163, __v_161, __v_162]; 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 __v_164: G = __r_arr[0];
+    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 = 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } 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_227] = { let __args: [G; IN_227] = [__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; 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 __ret: [G; OUT_230] = [];
+        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)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_251: G = G::from_u64(1);
+        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__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; 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 __ret: [G; OUT_230] = [];
+        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)); };
+        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_228] = { let __args: [G; IN_228] = [__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; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_230] = [];
+        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)); };
+        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_228] = { let __args: [G; IN_228] = [__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; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_230] = [];
+        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)); };
+        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_228] = { let __args: [G; IN_228] = [__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; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_230] = [];
+        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)); };
+        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_228] = { let __args: [G; IN_228] = [__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; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_230] = [];
+        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)); };
+        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_229] = { let __args: [G; IN_229] = [__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; 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 __ret: [G; OUT_230] = [];
+        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)); };
+        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_229] = { let __args: [G; IN_229] = [__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; 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 __ret: [G; OUT_230] = [];
+        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)); };
+        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_229] = { let __args: [G; IN_229] = [__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; 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 __ret: [G; OUT_230] = [];
+        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)); };
+        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_229] = { let __args: [G; IN_229] = [__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; 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 __ret: [G; OUT_230] = [];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_165.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_231: usize = 2;
+const IN_231: usize = 2;
+const OUT_231: usize = 1;
+fn aiur_fn_231(
+  inp: [G; IN_231],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_231], 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_238] = { let __args: [G; IN_238] = [__v_0, __v_1]; 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 __v_2: G = __r_arr[0];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_231] = [__v_4];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_232: usize = 1;
+const IN_232: usize = 1;
+const OUT_232: usize = 1;
+fn aiur_fn_232(
+  inp: [G; IN_232],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_232], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    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_232] = [__v_4];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_232] = [__v_4];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_233: usize = 2;
+const IN_233: usize = 2;
+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_233], 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_245] = { let __args: [G; IN_245] = [__v_0, __v_1]; 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 __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() {
+      0u64 => {
+        let __ret: [G; OUT_233] = [__v_4, __v_5];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_234: usize = 1;
+const IN_234: usize = 1;
+const OUT_234: usize = 1;
+fn aiur_fn_234(
+  inp: [G; IN_234],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_234], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_234] = [__v_6];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_5]; 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 __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_234] = [__v_8];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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 __v_0: G = inp[0];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_235] = [__v_5];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_4]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+        let __v_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_235] = [__v_7];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_236: usize = 2;
+const IN_236: usize = 2;
+const OUT_236: usize = 1;
+fn aiur_fn_236(
+  inp: [G; IN_236],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_236], 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 __ret: [G; OUT_236] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_12: G = G::from_u64(0);
+        let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_11, __v_1]; 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 __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_236] = [__v_14];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_237], 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() {
+      1u64 => {
+        let __ret: [G; OUT_237] = [__v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+        let __v_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_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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_238: usize = 2;
+const IN_238: usize = 2;
+const OUT_238: usize = 1;
+fn aiur_fn_238(
+  inp: [G; IN_238],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_238], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_238] = [__v_0];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_1 - __v_2);
+        let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0, __v_3]; 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 __v_4: G = __r_arr[0];
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_238] = [__v_7];
+            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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+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_239], 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_239] = [__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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        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 __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_239] = [__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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_240: usize = 1;
+const IN_240: usize = 1;
+const OUT_240: usize = 1;
+fn aiur_fn_240(
+  inp: [G; IN_240],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_240], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    let __v_7: G = __loaded[6];
+    let __v_8: G = __loaded[7];
+    let __v_9: G = __loaded[8];
+    let __v_10: G = __loaded[9];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_11: G = G::from_u64(0);
+        let __ret: [G; OUT_240] = [__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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_10]; 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 __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_240] = [__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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_241: usize = 2;
+const IN_241: usize = 2;
+const OUT_241: usize = 4;
+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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_1]; 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 __v_2: G = __r_arr[0];
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_241] = [__v_4, __v_5, __v_6, __v_7];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_242], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    let __v_7: G = __loaded[6];
+    let __v_8: G = __loaded[7];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_9: G = G::from_u64(0);
+        let __ret: [G; OUT_242] = [__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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; 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 __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_242] = [__v_11];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_243], 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_243] = [__v_4];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3]; 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_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 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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_244: usize = 2;
+const IN_244: usize = 2;
+const OUT_244: usize = 8;
+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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_1]; 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 __v_2: G = __r_arr[0];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    let __v_9: G = __loaded[6];
+    let __v_10: G = __loaded[7];
+    let __v_11: G = __loaded[8];
+    let __v_12: G = __loaded[9];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_244] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_245] = [__v_0];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_1 - __v_2);
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_0, __v_3]; 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 __v_4: G = __r_arr[0];
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_245] = [__v_8];
+            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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_246] = [__v_0];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_1 - __v_2);
+        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_3]; 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 __v_4: G = __r_arr[0];
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        let __v_9: G = __loaded[4];
+        let __v_10: G = __loaded[5];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_246] = [__v_10];
+            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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_247: usize = 2;
+const IN_247: usize = 2;
+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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_247] = [__v_0];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_1 - __v_2);
+        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_3]; 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 __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))?; 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_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_247] = [__v_14];
+            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)); };
+            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());
+    },
+    _ => {
+      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..81ca667e9
--- /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);
+  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_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..a62e396e8 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],
@@ -25,6 +25,399 @@ fn aiur_fn_0(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_0], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __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_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_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)); };
+                        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)); };
+                        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)); };
+                    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)); };
+                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)); };
+            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)); };
+        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 __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 = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __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_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_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 __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)); };
+        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)); };
+        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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_2], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -34,8 +427,8 @@ fn aiur_fn_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 __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 __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)); };
         return Ok(__ret);
       },
       _ => {
@@ -43,29 +436,29 @@ 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_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 __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 __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)); };
         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_3: usize = 8;
+const IN_3: usize = 8;
+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_1], ExecError> {
+) -> Result<[G; OUT_3], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -92,85 +485,85 @@ 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_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)); };
                                     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_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)); };
                                     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_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)); };
                                 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_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)); };
                             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_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)); };
                         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_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)); };
                     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_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)); };
                 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_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)); };
             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_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)); };
         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_4: usize = 8;
+const IN_4: usize = 8;
+const OUT_4: usize = 4;
+fn aiur_fn_4(
+  inp: [G; IN_4],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_2], ExecError> {
+) -> Result<[G; OUT_4], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -193,21 +586,21 @@ 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_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)); };
     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_5: usize = 12;
+const IN_5: usize = 12;
+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_3], ExecError> {
+) -> Result<[G; OUT_5], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -240,21 +633,21 @@ 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_5] = [__v_12, __v_13, __v_14, __v_15];
+    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)); };
     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_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_4], ExecError> {
+) -> Result<[G; OUT_6], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -268,61 +661,61 @@ 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_6] = [__v_8, __v_9, __v_10, __v_11];
+    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)); };
     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_7: usize = 4;
+const IN_7: usize = 4;
+const OUT_7: usize = 4;
+fn aiur_fn_7(
+  inp: [G; IN_7],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_5], ExecError> {
+) -> Result<[G; OUT_7], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __ret: [G; OUT_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_7] = [__v_2, __v_3, __v_0, __v_1];
+    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)); };
     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_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_6], ExecError> {
+) -> Result<[G; OUT_8], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __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_8] = [__v_1, __v_2, __v_3, __v_0];
+    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)); };
     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_9: usize = 8;
+const IN_9: usize = 8;
+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_7], ExecError> {
+) -> Result<[G; OUT_9], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -348,21 +741,21 @@ 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_9] = [__v_16, __v_17, __v_18, __v_19];
+    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)); };
     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_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_8], ExecError> {
+) -> Result<[G; OUT_10], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -388,21 +781,21 @@ 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_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)); };
     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_11: usize = 8;
+const IN_11: usize = 8;
+const OUT_11: usize = 8;
+fn aiur_fn_11(
+  inp: [G; IN_11],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_9], ExecError> {
+) -> Result<[G; OUT_11], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -436,8 +829,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_11] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+                                    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)); };
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -450,8 +843,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_11] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
+                                    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)); };
                                     return Ok(__ret);
                                   },
                                 }
@@ -465,8 +858,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_11] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
+                                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)); };
                                 return Ok(__ret);
                               },
                             }
@@ -479,8 +872,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_11] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
+                            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)); };
                             return Ok(__ret);
                           },
                         }
@@ -492,8 +885,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_11] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
+                        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)); };
                         return Ok(__ret);
                       },
                     }
@@ -504,8 +897,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_11] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
+                    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)); };
                     return Ok(__ret);
                   },
                 }
@@ -515,8 +908,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_11] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
+                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)); };
                 return Ok(__ret);
               },
             }
@@ -525,8 +918,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_11] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+            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)); };
             return Ok(__ret);
           },
         }
@@ -534,23 +927,23 @@ 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_11] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+        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)); };
         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],
-  record: &mut QueryRecord,
+const INPUT_SIZE_12: usize = 8;
+const IN_12: usize = 8;
+const OUT_12: usize = 1;
+fn aiur_fn_12(
+  inp: [G; IN_12],
+  record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_10], ExecError> {
+) -> Result<[G; OUT_12], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -582,21 +975,21 @@ 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_12] = [__v_26];
+    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)); };
     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_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_11], ExecError> {
+) -> Result<[G; OUT_13], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -627,21 +1020,21 @@ 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_13] = [__v_28];
+    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)); };
     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_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_12], ExecError> {
+) -> Result<[G; OUT_14], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -666,21 +1059,21 @@ 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_14] = [__v_22];
+    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)); };
     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_15: usize = 1;
+const IN_15: usize = 1;
+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_13], ExecError> {
+) -> Result<[G; OUT_15], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
@@ -739,21 +1132,21 @@ 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_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+    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)); };
     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_16: usize = 1;
+const IN_16: usize = 1;
+const OUT_16: usize = 1;
+fn aiur_fn_16(
+  inp: [G; IN_16],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_14], ExecError> {
+) -> Result<[G; OUT_16], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = g_inverse_value(__v_0);
@@ -770,21 +1163,21 @@ 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_16] = [__v_1];
+    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)); };
     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_17: usize = 4;
+const IN_17: usize = 4;
+const OUT_17: usize = 2;
+fn aiur_fn_17(
+  inp: [G; IN_17],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_15], ExecError> {
+) -> Result<[G; OUT_17], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -792,21 +1185,21 @@ fn aiur_fn_15(
     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_17] = [__v_4, __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)); };
     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_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_16], ExecError> {
+) -> Result<[G; OUT_18], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -814,21 +1207,21 @@ fn aiur_fn_16(
     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_18] = [__v_4, __v_5];
+    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)); };
     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_19: usize = 2;
+const IN_19: usize = 2;
+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_17], ExecError> {
+) -> Result<[G; OUT_19], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -836,21 +1229,21 @@ fn aiur_fn_17(
     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_19] = [__v_3, __v_5];
+    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)); };
     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_20: usize = 4;
+const IN_20: usize = 4;
+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_18], ExecError> {
+) -> Result<[G; OUT_20], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -864,21 +1257,21 @@ 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_20] = [__v_8, __v_11];
+    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)); };
     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_21: usize = 2;
+const IN_21: usize = 2;
+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_19], ExecError> {
+) -> Result<[G; OUT_21], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -905,21 +1298,21 @@ 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_21] = [__v_15, __v_18];
+    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)); };
     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_22: usize = 4;
+const IN_22: usize = 4;
+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_20], ExecError> {
+) -> Result<[G; OUT_22], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -956,21 +1349,21 @@ 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_22] = [__v_25, __v_28];
+    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)); };
     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_23: usize = 4;
+const IN_23: usize = 4;
+const OUT_23: usize = 1;
+fn aiur_fn_23(
+  inp: [G; IN_23],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_21], ExecError> {
+) -> Result<[G; OUT_23], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -981,21 +1374,21 @@ 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_23] = [__v_8];
+    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)); };
     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_24: usize = 1;
+const IN_24: usize = 1;
+const OUT_24: usize = 2;
+fn aiur_fn_24(
+  inp: [G; IN_24],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_22], ExecError> {
+) -> Result<[G; OUT_24], 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 };
@@ -1004,8 +1397,8 @@ fn aiur_fn_22(
     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_24] = [__v_2, __v_3];
+        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)); };
         return Ok(__ret);
       },
       1u64 => {
@@ -1013,8 +1406,8 @@ fn aiur_fn_22(
         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 __ret: [G; OUT_24] = [__v_4, __v_7];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -1024,59 +1417,59 @@ 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_25: usize = 1;
+const IN_25: usize = 1;
+const OUT_25: usize = 9;
+fn aiur_fn_25(
+  inp: [G; IN_25],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_23], ExecError> {
+) -> Result<[G; OUT_25], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     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_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_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_24] = { let __args: [G; IN_24] = [__v_2]; 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_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_24] = { let __args: [G; IN_24] = [__v_4]; 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_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_24] = { let __args: [G; IN_24] = [__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 __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_24] = { let __args: [G; IN_24] = [__v_8]; 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_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_24] = { let __args: [G; IN_24] = [__v_10]; 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_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_24] = { let __args: [G; IN_24] = [__v_12]; 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_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_24] = { let __args: [G; IN_24] = [__v_14]; 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_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_25] = [__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[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)); };
     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_26: usize = 1;
+const IN_26: usize = 1;
+const OUT_26: usize = 2;
+fn aiur_fn_26(
+  inp: [G; IN_26],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_24], ExecError> {
+) -> Result<[G; OUT_26], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     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_25] = { let __args: [G; IN_25] = [__v_0]; 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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -1086,23 +1479,23 @@ 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_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __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_26] = [__v_10, __v_9];
+    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)); };
     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_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_25], ExecError> {
+) -> Result<[G; OUT_27], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -1110,21 +1503,21 @@ fn aiur_fn_25(
     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_27] = [__v_2, __v_4];
+    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)); };
     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_28: usize = 1;
+const IN_28: usize = 1;
+const OUT_28: usize = 9;
+fn aiur_fn_28(
+  inp: [G; IN_28],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_26], ExecError> {
+) -> Result<[G; OUT_28], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -1139,24 +1532,24 @@ 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_28] = [__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[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)); };
     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_29: usize = 1;
+const IN_29: usize = 1;
+const OUT_29: usize = 2;
+fn aiur_fn_29(
+  inp: [G; IN_29],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_27], ExecError> {
+) -> Result<[G; OUT_29], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -1166,26 +1559,26 @@ 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_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __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_29] = [__v_10, __v_9];
+    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)); };
     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_30: usize = 1;
+const IN_30: usize = 1;
+const OUT_30: usize = 3;
+fn aiur_fn_30(
+  inp: [G; IN_30],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_28], ExecError> {
+) -> Result<[G; OUT_30], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -1195,7 +1588,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_28] = { let __args: [G; IN_28] = [__v_9]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -1247,24 +1640,24 @@ 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_30] = [__v_39, __v_60, __v_18];
+    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)); };
     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_31: usize = 1;
+const IN_31: usize = 1;
+const OUT_31: usize = 33;
+fn aiur_fn_31(
+  inp: [G; IN_31],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_29], ExecError> {
+) -> Result<[G; OUT_31], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -1274,7 +1667,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_28] = { let __args: [G; IN_28] = [__v_9]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -1284,7 +1677,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_28] = { let __args: [G; IN_28] = [__v_18]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
     let __v_21: G = __r_arr[2];
@@ -1294,7 +1687,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_28] = { let __args: [G; IN_28] = [__v_27]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
     let __v_28: G = __r_arr[0];
     let __v_29: G = __r_arr[1];
     let __v_30: G = __r_arr[2];
@@ -1304,44 +1697,44 @@ 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_31] = [__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[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)); };
     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_32: usize = 1;
+const IN_32: usize = 1;
+const OUT_32: usize = 2;
+fn aiur_fn_32(
+  inp: [G; IN_32],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_30], ExecError> {
+) -> Result<[G; OUT_32], 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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_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 __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_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)); };
     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_33: usize = 2;
+const IN_33: usize = 2;
+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_31], ExecError> {
+) -> Result<[G; OUT_33], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1350,61 +1743,61 @@ fn aiur_fn_31(
         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 __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)); };
         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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; 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 { 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_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_33] = { let __args: [G; IN_33] = [__v_3, __v_5]; 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_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 __ret: [G; OUT_33] = [__v_9, __v_7];
+        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)); };
         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_34: usize = 1;
+const IN_34: usize = 1;
+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_32], ExecError> {
+) -> Result<[G; OUT_34], 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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_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 __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_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)); };
     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_35: usize = 2;
+const IN_35: usize = 2;
+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_33], ExecError> {
+) -> Result<[G; OUT_35], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1413,12 +1806,12 @@ fn aiur_fn_33(
         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 __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)); };
         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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -1430,51 +1823,51 @@ 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_35] = { let __args: [G; IN_35] = [__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 __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 __ret: [G; OUT_35] = [__v_16, __v_14];
+        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_34: usize = 1;
-const IN_34: usize = 1;
-const OUT_34: usize = 2;
-fn aiur_fn_34(
-  inp: [G; IN_34],
+const INPUT_SIZE_36: usize = 1;
+const IN_36: usize = 1;
+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_34], ExecError> {
+) -> Result<[G; OUT_36], 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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_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 __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_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)); };
     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_37: usize = 2;
+const IN_37: usize = 2;
+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_35], ExecError> {
+) -> Result<[G; OUT_37], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1483,12 +1876,12 @@ fn aiur_fn_35(
         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 __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)); };
         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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -1498,7 +1891,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_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -1552,51 +1945,51 @@ 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_37] = { let __args: [G; IN_37] = [__v_19, __v_63]; 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 __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 __ret: [G; OUT_37] = [__v_67, __v_65];
+        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)); };
         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_38: usize = 1;
+const IN_38: usize = 1;
+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_36], ExecError> {
+) -> Result<[G; OUT_38], 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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_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 __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_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)); };
     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_39: usize = 2;
+const IN_39: usize = 2;
+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_37], ExecError> {
+) -> Result<[G; OUT_39], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1605,12 +1998,12 @@ fn aiur_fn_37(
         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 __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)); };
         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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -1620,7 +2013,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_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -1630,7 +2023,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_28] = { let __args: [G; IN_28] = [__v_19]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -1640,7 +2033,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_28] = { let __args: [G; IN_28] = [__v_28]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
         let __v_30: G = __r_arr[1];
         let __v_31: G = __r_arr[2];
@@ -1652,76 +2045,13 @@ 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_39] = { let __args: [G; IN_39] = [__v_37, __v_39]; 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_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)); };
-        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],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_38], 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_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 __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)); };
-    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],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_39], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    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)); };
-        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 __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 __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];
+        let __ret: [G; OUT_39] = [__v_44, __v_41];
         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)); };
         return Ok(__ret);
       },
@@ -1740,7 +2070,7 @@ fn aiur_fn_40(
 ) -> Result<[G; OUT_40], 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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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)? } };
@@ -1803,7 +2133,7 @@ fn aiur_fn_42(
 ) -> 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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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)? } };
@@ -1837,7 +2167,7 @@ fn aiur_fn_43(
         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_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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = G::from_u64(1);
@@ -1866,17 +2196,20 @@ fn aiur_fn_44(
 ) -> 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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __ret: [G; OUT_44] = [__v_1, __v_2];
+    let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_2, __v_1]; 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 = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_44] = [__v_3, __v_4];
     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 INPUT_SIZE_45: usize = 2;
+const IN_45: usize = 2;
 const OUT_45: usize = 2;
 fn aiur_fn_45(
   inp: [G; IN_45],
@@ -1884,29 +2217,6 @@ fn aiur_fn_45(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_45], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __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_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 __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)); };
-    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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1915,32 +2225,52 @@ fn aiur_fn_46(
         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_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)); };
+        let __ret: [G; OUT_45] = [__v_4, __v_0];
+        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)); };
         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_42] = { let __args: [G; IN_42] = [__v_0]; 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_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_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 __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_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)); };
+        let __ret: [G; OUT_45] = [__v_9, __v_7];
+        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)); };
         return Ok(__ret);
       },
     }
   })
 }
 
+const INPUT_SIZE_46: usize = 1;
+const IN_46: usize = 1;
+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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; 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 __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __ret: [G; OUT_46] = [__v_1, __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)); };
+    return Ok(__ret);
+  })
+}
+
 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,
@@ -1949,24 +2279,21 @@ fn aiur_fn_47(
 ) -> Result<[G; OUT_47], 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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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; 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 __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];
+    let __ret: [G; OUT_47] = [__v_3, __v_4];
     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)); };
     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,
@@ -1975,24 +2302,38 @@ fn aiur_fn_48(
 ) -> Result<[G; OUT_48], 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_48] = [__v_4, __v_0];
+        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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; 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 __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; 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 __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_48] = [__v_9, __v_7];
+        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);
+      },
+    }
   })
 }
 
 const INPUT_SIZE_49: usize = 1;
 const IN_49: usize = 1;
-const OUT_49: usize = 2;
+const OUT_49: usize = 4;
 fn aiur_fn_49(
   inp: [G; IN_49],
   record: &mut QueryRecord,
@@ -2001,21 +2342,24 @@ fn aiur_fn_49(
 ) -> Result<[G; OUT_49], 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 __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0]; 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 __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_38] = { let __args: [G; IN_38] = [__v_2]; 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 __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_49] = [__v_3, __v_4];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; 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 __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_49] = [__v_1, __v_3, __v_5, __v_6];
     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)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_50: usize = 2;
-const IN_50: usize = 2;
-const OUT_50: usize = 2;
+const INPUT_SIZE_50: usize = 1;
+const IN_50: usize = 1;
+const OUT_50: usize = 3;
 fn aiur_fn_50(
   inp: [G; IN_50],
   record: &mut QueryRecord,
@@ -2024,44 +2368,24 @@ fn aiur_fn_50(
 ) -> Result<[G; OUT_50], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    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)); };
-        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 __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_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)); };
-        return Ok(__ret);
-      },
-    }
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_4]; 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 __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_50] = [__v_3, __v_5, __v_6];
+    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)); };
+    return Ok(__ret);
   })
 }
 
 const INPUT_SIZE_51: usize = 1;
 const IN_51: usize = 1;
-const OUT_51: usize = 4;
+const OUT_51: usize = 2;
 fn aiur_fn_51(
   inp: [G; IN_51],
   record: &mut QueryRecord,
@@ -2070,23 +2394,20 @@ fn aiur_fn_51(
 ) -> Result<[G; OUT_51], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     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_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_52] = { let __args: [G; IN_52] = [__v_2, __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 __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_51] = [__v_1, __v_3, __v_5, __v_6];
+    let __ret: [G; OUT_51] = [__v_3, __v_4];
     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)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_52: usize = 1;
-const IN_52: usize = 1;
+const INPUT_SIZE_52: usize = 2;
+const IN_52: usize = 2;
 const OUT_52: usize = 2;
 fn aiur_fn_52(
   inp: [G; IN_52],
@@ -2096,27 +2417,99 @@ fn aiur_fn_52(
 ) -> Result<[G; OUT_52], 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_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_52] = [__v_4, __v_0];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_3, __v_2]; 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_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_5]; 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 __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_52] = { let __args: [G; IN_52] = [__v_7, __v_9]; 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 __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_52] = [__v_13, __v_11];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_53: usize = 1;
+const IN_53: usize = 1;
+const OUT_53: usize = 4;
+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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; 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 { 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_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_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 __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_38] = { let __args: [G; IN_38] = [__v_4]; 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 __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_53] = [__v_1, __v_3, __v_5, __v_6];
+    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)); };
     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 __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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; 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 __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_54] = [__v_3, __v_4];
+    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)); };
+    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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2125,96 +2518,96 @@ fn aiur_fn_53(
         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 __ret: [G; OUT_55] = [__v_4, __v_0];
+        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)); };
         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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; 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 { 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_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_36] = { let __args: [G; IN_36] = [__v_3]; 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 = __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_38] = { let __args: [G; IN_38] = [__v_5]; 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 __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; 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 __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 __ret: [G; OUT_55] = [__v_13, __v_11];
+        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)); };
         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 = 3;
+fn aiur_fn_56(
+  inp: [G; IN_56],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_54], ExecError> {
+) -> Result<[G; OUT_56], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __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_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_52] = { let __args: [G; IN_52] = [__v_2, __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 __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_29] = { let __args: [G; IN_29] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_55] = { let __args: [G; IN_55] = [__v_6, __v_5]; 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 __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_3, __v_7, __v_8];
+    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)); };
     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 __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_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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; 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_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 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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2223,68 +2616,68 @@ fn aiur_fn_56(
         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 __ret: [G; OUT_58] = [__v_4, __v_0];
+        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)); };
         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_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_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_52] = { let __args: [G; IN_52] = [__v_3, __v_2]; 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 __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_29] = { let __args: [G; IN_29] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_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_55] = { let __args: [G; IN_55] = [__v_7, __v_6]; 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 __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; 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_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 __ret: [G; OUT_58] = [__v_15, __v_13];
+        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)); };
         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 = 13;
+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 __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_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_48] = { let __args: [G; IN_48] = [__v_2, __v_1]; 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 __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_34] = { let __args: [G; IN_34] = [__v_4]; 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_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_29] = { let __args: [G; IN_29] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_58] = { let __args: [G; IN_58] = [__v_8, __v_7]; 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_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_36] = { let __args: [G; IN_36] = [__v_10]; 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_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_28] = { let __args: [G; IN_28] = [__v_12]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
     let __v_15: G = __r_arr[2];
@@ -2294,101 +2687,101 @@ fn aiur_fn_57(
     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 __ret: [G; OUT_59] = [__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[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)); };
     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 __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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; 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 { 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];
     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 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)); };
         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_44] = { let __args: [G; IN_44] = [__v_2]; 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 __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 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)); };
         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 = 24;
+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 __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_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_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 __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_38] = { let __args: [G; IN_38] = [__v_4]; 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 __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_38] = { let __args: [G; IN_38] = [__v_6]; 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 __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_38] = { let __args: [G; IN_38] = [__v_8]; 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 __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_36] = { let __args: [G; IN_36] = [__v_10]; 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_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_29] = { let __args: [G; IN_29] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_33] = { let __args: [G; IN_33] = [__v_14, __v_13]; 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_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_29] = { let __args: [G; IN_29] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_48] = { let __args: [G; IN_48] = [__v_18, __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 __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_34] = { let __args: [G; IN_34] = [__v_20]; 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 = __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_29] = { let __args: [G; IN_29] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_23: G = __r_arr[0];
     let __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_58] = { let __args: [G; IN_58] = [__v_24, __v_23]; 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_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_36] = { let __args: [G; IN_36] = [__v_26]; 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_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_28] = { let __args: [G; IN_28] = [__v_28]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
     let __v_29: G = __r_arr[0];
     let __v_30: G = __r_arr[1];
     let __v_31: G = __r_arr[2];
@@ -2398,34 +2791,34 @@ fn aiur_fn_59(
     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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_37]; 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 __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 __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_39]; 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 __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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_42]; 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 __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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_44]; 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 __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 __ret: [G; OUT_61] = [__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[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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2440,21 +2833,21 @@ 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 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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2560,21 +2953,21 @@ 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 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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = G::from_u64(103);
@@ -2627,9 +3020,9 @@ fn aiur_fn_62(
     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 __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; 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 __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; 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 __v_52: G = __r_arr[0];
     let __v_53: G = __r_arr[1];
     let __v_54: G = __r_arr[2];
@@ -2662,21 +3055,124 @@ 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 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)); };
     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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = G::from_u64(1);
+    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __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 __v_51: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_84];
+    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)); };
+    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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2750,13 +3246,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 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)); };
         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; 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 __v_69: G = __r_arr[0];
         let __v_70: G = __r_arr[1];
         let __v_71: G = __r_arr[2];
@@ -2794,8 +3290,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 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)); };
             return Ok(__ret);
           },
           1u64 => {
@@ -2904,7 +3400,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; 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 __v_205: G = __r_arr[0];
                 let __v_206: G = __r_arr[1];
                 let __v_207: G = __r_arr[2];
@@ -2941,8 +3437,8 @@ fn aiur_fn_63(
                 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 __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 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)); };
                 return Ok(__ret);
               },
               _ => {
@@ -2978,7 +3474,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; 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 __v_203: G = __r_arr[0];
                 let __v_204: G = __r_arr[1];
                 let __v_205: G = __r_arr[2];
@@ -3015,8 +3511,8 @@ fn aiur_fn_63(
                 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 __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 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)); };
                 return Ok(__ret);
               },
             }
@@ -3033,15 +3529,15 @@ 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 __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 };
@@ -3118,13 +3614,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 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)); };
             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; 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 __v_70: G = __r_arr[0];
             let __v_71: G = __r_arr[1];
             let __v_72: G = __r_arr[2];
@@ -3161,7 +3657,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; 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 __v_104: G = __r_arr[0];
                 let __v_105: G = __r_arr[1];
                 let __v_106: G = __r_arr[2];
@@ -3194,14 +3690,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 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)); };
                 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 __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_105]; 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 __v_106: G = __r_arr[0];
                 let __v_107: G = __r_arr[1];
                 let __v_108: G = __r_arr[2];
@@ -3234,8 +3730,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 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)); };
                 return Ok(__ret);
               },
               _ => {
@@ -3252,15 +3748,15 @@ 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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -3275,10 +3771,10 @@ fn aiur_fn_65(
     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; 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_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 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)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -3286,10 +3782,10 @@ fn aiur_fn_65(
         let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         match __v_2.as_canonical_u64() {
           63u64 => {
-            let __r_arr: [G; OUT_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; 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 __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 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)); };
             return Ok(__ret);
           },
           _ => {
@@ -3297,10 +3793,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; 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 __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 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)); };
             return Ok(__ret);
           },
         }
@@ -3312,15 +3808,15 @@ 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 __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 };
@@ -3707,8 +4203,8 @@ fn aiur_fn_66(
                                                                                                                                                                                                                                                                 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 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)); };
                                                                                                                                                                                                                                                                     return Ok(__ret);
                                                                                                                                                                                                                                                                   },
                                                                                                                                                                                                                                                                   _ => {
@@ -4033,22 +4529,22 @@ 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 __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 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)); };
         return Ok(__ret);
       },
       _ => {
@@ -4057,25 +4553,25 @@ fn aiur_fn_67(
         let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_1 - __v_5);
-        let __r_arr: [G; OUT_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; 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 __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 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)); };
         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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -4248,7 +4744,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; 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 __v_148: G = __r_arr[0];
                                             let __v_149: G = __r_arr[1];
                                             let __v_150: G = __r_arr[2];
@@ -4282,62 +4778,62 @@ fn aiur_fn_68(
                                             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 __ret: [G; OUT_71] = [__v_180];
+                                            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)); };
                                             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 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)); };
                                             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 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)); };
                                         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 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)); };
                                     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 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)); };
                                 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 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)); };
                             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 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)); };
                         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 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)); };
                     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 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)); };
                 return Ok(__ret);
               },
             }
@@ -4378,8 +4874,8 @@ fn aiur_fn_68(
             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 __ret: [G; OUT_71] = [__v_42];
+            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)); };
             return Ok(__ret);
           },
         }
@@ -4394,7 +4890,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_3] = { let __args: [G; IN_3] = [__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[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_17: G = __r_arr[0];
         let __v_18: G = (__v_17 * __v_8);
         let __v_19: G = (__v_2 - __v_1);
@@ -4404,9 +4900,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; 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 __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; 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 __v_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
         let __v_29: G = __r_arr[2];
@@ -4537,7 +5033,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; 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 __v_155: G = __r_arr[0];
         let __v_156: G = __r_arr[1];
         let __v_157: G = __r_arr[2];
@@ -4571,23 +5067,23 @@ fn aiur_fn_68(
         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 __ret: [G; OUT_71] = [__v_187];
+        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)); };
         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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -4598,7 +5094,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; 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 __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
     let __v_11: G = __r_arr[2];
@@ -4665,7 +5161,7 @@ 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_231] = { let __args: [G; IN_231] = [__v_0]; 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 __v_73: G = __r_arr[0];
         let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_74: G = __loaded[0];
@@ -4676,7 +5172,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_3] = { let __args: [G; IN_3] = [__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[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_82: G = __r_arr[0];
         let __v_83: G = (__v_73 * __v_82);
         let __v_84: G = (__v_8 * __v_83);
@@ -4780,7 +5276,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; 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 __v_183: G = __r_arr[0];
         let __v_184: G = __r_arr[1];
         let __v_185: G = __r_arr[2];
@@ -4828,7 +5324,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_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_11(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
         let __v_229: G = __r_arr[0];
         let __v_230: G = __r_arr[1];
         let __v_231: G = __r_arr[2];
@@ -4839,17 +5335,17 @@ fn aiur_fn_69(
         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 __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; 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 __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 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)); };
         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_231] = { let __args: [G; IN_231] = [__v_0]; 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 __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_231] = { let __args: [G; IN_231] = [__v_0]; 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 __v_75: G = __r_arr[0];
         let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_76: G = __loaded[0];
@@ -4860,7 +5356,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_3] = { let __args: [G; IN_3] = [__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[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_84: G = __r_arr[0];
         let __v_85: G = (__v_84 * __v_8);
         let __v_86: G = (__v_75 * __v_85);
@@ -4936,7 +5432,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; 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 __v_157: G = __r_arr[0];
         let __v_158: G = __r_arr[1];
         let __v_159: G = __r_arr[2];
@@ -4976,25 +5472,25 @@ fn aiur_fn_69(
         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 __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; 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 __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 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)); };
         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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -5124,21 +5620,21 @@ 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 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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -6100,21 +6596,21 @@ 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 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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -6245,7 +6741,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; 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 __v_129: G = __r_arr[0];
     let __v_130: G = __r_arr[1];
     let __v_131: G = __r_arr[2];
@@ -6278,21 +6774,21 @@ 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 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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -6457,8 +6953,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 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)); };
         return Ok(__ret);
       },
       _ => {
@@ -7296,7 +7792,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; 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 __v_675: G = __r_arr[0];
         let __v_676: G = __r_arr[1];
         let __v_677: G = __r_arr[2];
@@ -7329,23 +7825,23 @@ 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 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)); };
         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 __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 };
@@ -7354,8 +7850,8 @@ fn aiur_fn_74(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_74] = [__v_2, __v_3];
-        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 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)); };
         return Ok(__ret);
       },
       _ => {
@@ -7365,67 +7861,67 @@ 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 __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; 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_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 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)); };
     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 __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; 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_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; 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_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 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)); };
     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 __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; 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_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; 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = G::from_u64(256);
@@ -7437,33 +7933,33 @@ 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 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)); };
     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 __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; 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_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; 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_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; 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_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; 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_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
     let __v_9: G = G::from_u64(256);
@@ -7479,65 +7975,65 @@ 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 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)); };
     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 __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; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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 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)); };
     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 __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; 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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -7568,24 +8064,24 @@ 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 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)); };
     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 __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; 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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -7595,7 +8091,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; 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 __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -7605,7 +8101,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; 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 __v_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
     let __v_21: G = __r_arr[2];
@@ -7615,7 +8111,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; 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 __v_28: G = __r_arr[0];
     let __v_29: G = __r_arr[1];
     let __v_30: G = __r_arr[2];
@@ -7625,21 +8121,21 @@ 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 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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7648,12 +8144,12 @@ fn aiur_fn_82(
         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 __ret: [G; OUT_85] = [__v_4, __v_0];
+        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)); };
         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; 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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -7663,7 +8159,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; 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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -7673,7 +8169,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; 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 __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -7683,7 +8179,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; 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 __v_29: G = __r_arr[0];
         let __v_30: G = __r_arr[1];
         let __v_31: G = __r_arr[2];
@@ -7695,29 +8191,29 @@ 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; 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 __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 __ret: [G; OUT_85] = [__v_44, __v_41];
+        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)); };
         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],
+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_83], ExecError> {
+) -> Result<[G; OUT_86], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7726,192 +8222,192 @@ fn aiur_fn_83(
         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 __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)); };
         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; 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 __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; 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 __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; 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_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 __ret: [G; OUT_86] = [__v_13, __v_9];
+            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)); };
             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; 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 __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; 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_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 __ret: [G; OUT_86] = [__v_13, __v_9];
+            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)); };
             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; 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 __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; 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_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 __ret: [G; OUT_86] = [__v_13, __v_9];
+            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)); };
             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; 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_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 __ret: [G; OUT_86] = [__v_11, __v_7];
+            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)); };
             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; 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_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 __ret: [G; OUT_86] = [__v_11, __v_7];
+            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)); };
             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; 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_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 __ret: [G; OUT_86] = [__v_11, __v_7];
+            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)); };
             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; 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 __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; 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 __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; 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 = 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 __ret: [G; OUT_86] = [__v_15, __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)); };
             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; 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 __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; 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 __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; 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 = 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 __ret: [G; OUT_86] = [__v_15, __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)); };
             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; 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 __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; 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 __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; 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 = 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 __ret: [G; OUT_86] = [__v_15, __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)); };
             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; 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 __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; 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_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 __ret: [G; OUT_86] = [__v_13, __v_9];
+            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)); };
             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; 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 __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; 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
@@ -7919,17 +8415,17 @@ fn aiur_fn_83(
             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 __ret: [G; OUT_86] = [__v_14, __v_9];
+            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)); };
             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; 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 __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; 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
@@ -7937,17 +8433,17 @@ fn aiur_fn_83(
             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 __ret: [G; OUT_86] = [__v_14, __v_9];
+            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)); };
             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; 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 __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; 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
@@ -7955,17 +8451,17 @@ fn aiur_fn_83(
             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 __ret: [G; OUT_86] = [__v_14, __v_9];
+            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)); };
             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; 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 __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; 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
@@ -7973,17 +8469,17 @@ fn aiur_fn_83(
             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 __ret: [G; OUT_86] = [__v_14, __v_9];
+            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)); };
             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; 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 __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; 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
@@ -7991,17 +8487,17 @@ fn aiur_fn_83(
             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 __ret: [G; OUT_86] = [__v_14, __v_9];
+            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)); };
             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; 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 __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; 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
@@ -8009,8 +8505,8 @@ fn aiur_fn_83(
             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 __ret: [G; OUT_86] = [__v_14, __v_9];
+            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)); };
             return Ok(__ret);
           },
         }
@@ -8019,15 +8515,15 @@ 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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8036,64 +8532,74 @@ fn aiur_fn_84(
         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 __ret: [G; OUT_87] = [__v_4, __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)); };
         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; 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 __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; 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 __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 __ret: [G; OUT_87] = [__v_9, __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)); };
         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 __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; 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 __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; 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 __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; 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 __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; 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 __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 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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8102,44 +8608,54 @@ fn aiur_fn_86(
         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 __ret: [G; OUT_89] = [__v_4, __v_0];
+        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);
       },
       _ => {
-        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; 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 __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; 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 __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; 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 __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; 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 __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; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+        let __v_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_22, __v_20];
+        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_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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8147,8 +8663,8 @@ fn aiur_fn_87(
     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 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)); };
         return Ok(__ret);
       },
       _ => {
@@ -8159,11 +8675,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; 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_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 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)); };
             return Ok(__ret);
           },
           _ => {
@@ -8171,10 +8687,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; 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_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 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)); };
             return Ok(__ret);
           },
         }
@@ -8183,18 +8699,18 @@ 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 __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; 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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -8205,7 +8721,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; 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 __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -8216,7 +8732,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; 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 __v_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -8227,7 +8743,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; 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 __v_31: G = __r_arr[0];
     let __v_32: G = __r_arr[1];
     let __v_33: G = __r_arr[2];
@@ -8238,29 +8754,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; 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 __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; 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 __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; 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_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; 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 __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; 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 __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; 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 __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; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
     let __v_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; 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_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,21 +8951,21 @@ 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 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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8522,21 +9038,21 @@ fn aiur_fn_89(
     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 __ret: [G; OUT_92] = [__v_70];
+    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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8548,12 +9064,12 @@ fn aiur_fn_90(
         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 __ret: [G; OUT_93] = [__v_4, __v_7, __v_0];
+        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)); };
         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; 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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -8564,7 +9080,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; 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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -8575,7 +9091,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; 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 __v_22: G = __r_arr[0];
         let __v_23: G = __r_arr[1];
         let __v_24: G = __r_arr[2];
@@ -8586,7 +9102,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; 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 __v_32: G = __r_arr[0];
         let __v_33: G = __r_arr[1];
         let __v_34: G = __r_arr[2];
@@ -8597,29 +9113,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; 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 __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; 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 __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; 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_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; 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 __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; 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 __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; 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 __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; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
         let __v_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; 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_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,7 +9312,7 @@ 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; 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 __v_200: G = __r_arr[0];
         let __v_201: G = __r_arr[1];
         let __v_202: G = __r_arr[2];
@@ -8816,61 +9332,61 @@ fn aiur_fn_90(
         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 __ret: [G; OUT_93] = [__v_204, __v_218, __v_202];
+        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)); };
         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 __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; 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_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 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)); };
         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; 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 __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; 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 __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 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)); };
         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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8879,17 +9395,17 @@ fn aiur_fn_92(
         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 __ret: [G; OUT_95] = [__v_4, __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)); };
         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; 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 __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; 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         match __v_2.as_canonical_u64() {
@@ -8898,16 +9414,16 @@ fn aiur_fn_92(
             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 __ret: [G; OUT_95] = [__v_11, __v_7];
+            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)); };
             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 __ret: [G; OUT_95] = [__v_10, __v_7];
+            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)); };
             return Ok(__ret);
           },
         }
@@ -8916,18 +9432,18 @@ 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 __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; 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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -8938,7 +9454,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; 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 __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -8949,7 +9465,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; 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 __v_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -8960,7 +9476,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; 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 __v_31: G = __r_arr[0];
     let __v_32: G = __r_arr[1];
     let __v_33: G = __r_arr[2];
@@ -8971,7 +9487,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; 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 __v_41: G = __r_arr[0];
     let __v_42: G = __r_arr[1];
     let __v_43: G = __r_arr[2];
@@ -8982,7 +9498,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; 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 __v_51: G = __r_arr[0];
     let __v_52: G = __r_arr[1];
     let __v_53: G = __r_arr[2];
@@ -8993,7 +9509,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; 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 __v_61: G = __r_arr[0];
     let __v_62: G = __r_arr[1];
     let __v_63: G = __r_arr[2];
@@ -9021,24 +9537,24 @@ fn aiur_fn_93(
     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 __ret: [G; OUT_96] = [__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[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)); };
     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 __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; 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 __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -9049,7 +9565,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; 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 __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -9060,7 +9576,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; 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 __v_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -9071,7 +9587,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; 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 __v_31: G = __r_arr[0];
     let __v_32: G = __r_arr[1];
     let __v_33: G = __r_arr[2];
@@ -9082,7 +9598,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; 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 __v_41: G = __r_arr[0];
     let __v_42: G = __r_arr[1];
     let __v_43: G = __r_arr[2];
@@ -9093,7 +9609,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; 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 __v_51: G = __r_arr[0];
     let __v_52: G = __r_arr[1];
     let __v_53: G = __r_arr[2];
@@ -9104,7 +9620,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; 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 __v_61: G = __r_arr[0];
     let __v_62: G = __r_arr[1];
     let __v_63: G = __r_arr[2];
@@ -9132,7 +9648,7 @@ fn aiur_fn_94(
     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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_70]; 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 __v_88: G = __r_arr[0];
     let __v_89: G = __r_arr[1];
     let __v_90: G = __r_arr[2];
@@ -9143,36 +9659,95 @@ 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; 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 __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; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_94(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } } else { aiur_fn_94(__args, record, io_buffer, __cu)? } };
     let __v_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; 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_87, __v_155]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+    let __v_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 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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9187,21 +9762,21 @@ fn aiur_fn_95(
     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 __ret: [G; OUT_98] = [__v_12];
+    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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9236,37 +9811,37 @@ 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; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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; 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_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 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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9300,21 +9875,21 @@ 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 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)); };
     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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9449,7 +10024,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; 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 __v_131: G = __r_arr[0];
     let __v_132: G = __r_arr[1];
     let __v_133: G = __r_arr[2];
@@ -9483,53 +10058,53 @@ fn aiur_fn_98(
     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 __ret: [G; OUT_101] = [__v_163];
+    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)); };
     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 __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; 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 __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 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)); };
         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; 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 __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 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)); };
         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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9540,8 +10115,8 @@ fn aiur_fn_100(
     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 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)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -9550,15 +10125,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 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)); };
             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; 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_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 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)); };
             return Ok(__ret);
           },
         }
@@ -9570,15 +10145,15 @@ 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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9592,8 +10167,8 @@ fn aiur_fn_101(
         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 __ret: [G; OUT_104] = [__v_8];
+        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)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -9607,10 +10182,10 @@ 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; 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 __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 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)); };
                 return Ok(__ret);
               },
               _ => {
@@ -9627,19 +10202,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; 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 __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 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)); };
                     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; 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 __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 __ret: [G; OUT_104] = [__v_23];
+                    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)); };
                     return Ok(__ret);
                   },
                 }
@@ -9658,15 +10233,15 @@ 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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9761,8 +10336,8 @@ 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 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)); };
         return Ok(__ret);
       },
       1u64 => {
@@ -9781,12 +10356,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 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)); };
             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; 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_15: G = __r_arr[0];
             let __v_16: G = __r_arr[1];
             let __v_17: G = __r_arr[2];
@@ -9798,8 +10373,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 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)); };
             return Ok(__ret);
           },
           _ => {
@@ -9814,15 +10389,15 @@ 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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9830,7 +10405,7 @@ fn aiur_fn_103(
     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; 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 = __r_arr[1];
     let __v_8: G = __r_arr[2];
@@ -10001,7 +10576,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; 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 __v_155: G = __r_arr[0];
                                         let __v_156: G = __r_arr[1];
                                         let __v_157: G = __r_arr[2];
@@ -10035,68 +10610,68 @@ fn aiur_fn_103(
                                         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 __ret: [G; OUT_106] = [__v_187];
+                                        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)); };
                                         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 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)); };
                                         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 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)); };
                                     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 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)); };
                                 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 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)); };
                             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 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)); };
                         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 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)); };
                     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 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)); };
                 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 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)); };
             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; 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_17: G = __r_arr[0];
         let __v_18: G = __r_arr[1];
         let __v_19: G = __r_arr[2];
@@ -10108,7 +10683,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; 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -10120,7 +10695,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; 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_39: G = __r_arr[0];
         let __v_40: G = __r_arr[1];
         let __v_41: G = __r_arr[2];
@@ -10132,7 +10707,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; 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_50: G = __r_arr[0];
         let __v_51: G = __r_arr[1];
         let __v_52: G = __r_arr[2];
@@ -10144,7 +10719,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; 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_61: G = __r_arr[0];
         let __v_62: G = __r_arr[1];
         let __v_63: G = __r_arr[2];
@@ -10156,7 +10731,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; 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_72: G = __r_arr[0];
         let __v_73: G = __r_arr[1];
         let __v_74: G = __r_arr[2];
@@ -10168,7 +10743,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; 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_83: G = __r_arr[0];
         let __v_84: G = __r_arr[1];
         let __v_85: G = __r_arr[2];
@@ -10240,7 +10815,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_3] = { let __args: [G; IN_3] = [__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[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_129: G = __r_arr[0];
         let __v_130: G = (__v_113 * __v_129);
         let __v_131: G = G::from_u64(2);
@@ -10314,7 +10889,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; 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 __v_200: G = __r_arr[0];
         let __v_201: G = __r_arr[1];
         let __v_202: G = __r_arr[2];
@@ -10351,8 +10926,8 @@ fn aiur_fn_103(
           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 __ret: [G; OUT_106] = [__v_233];
+            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)); };
             return Ok(__ret);
           },
           _ => {
@@ -10400,7 +10975,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_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_11(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
                 let __v_273: G = __r_arr[0];
                 let __v_274: G = __r_arr[1];
                 let __v_275: G = __r_arr[2];
@@ -10413,20 +10988,20 @@ fn aiur_fn_103(
                 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_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 __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; 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 __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 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)); };
                 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 __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; 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 __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 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)); };
                 return Ok(__ret);
               },
             }
@@ -10437,15 +11012,15 @@ 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 __v_0: G = inp[0];
     let __v_1: G = G::from_u64(103);
@@ -10497,9 +11072,9 @@ fn aiur_fn_104(
     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 __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; 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 __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; 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 __v_51: G = __r_arr[0];
     let __v_52: G = __r_arr[1];
     let __v_53: G = __r_arr[2];
@@ -10532,26 +11107,26 @@ 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 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)); };
     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 __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; 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 __v_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(103);
     let __v_5: G = G::from_u64(230);
@@ -10602,9 +11177,9 @@ fn aiur_fn_105(
     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 __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; 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 __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; 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 __v_54: G = __r_arr[0];
     let __v_55: G = __r_arr[1];
     let __v_56: G = __r_arr[2];
@@ -10638,56 +11213,56 @@ fn aiur_fn_105(
     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 __ret: [G; OUT_108] = [__v_86];
+    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)); };
     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 __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; 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_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 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);
       },
       _ => {
-        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; 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_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; 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 __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 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_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 __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 };
@@ -10697,18 +11272,18 @@ fn aiur_fn_107(
     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 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);
       },
       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; 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_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 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);
       },
       _ => {
@@ -10718,15 +11293,15 @@ 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 = 6;
+const IN_111: usize = 6;
+const OUT_111: usize = 2;
+fn aiur_fn_111(
+  inp: [G; IN_111],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_108], ExecError> {
+) -> Result<[G; OUT_111], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10740,10 +11315,10 @@ fn aiur_fn_108(
     let __v_8: G = __loaded[2];
     match __v_6.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 __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_4]; 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_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_0, __v_9];
+        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);
       },
       0u64 => {
@@ -10755,28 +11330,28 @@ fn aiur_fn_108(
           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 __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_0, __v_7]; 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 __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 __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_7, __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 __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 __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_2, __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_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 __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1, __v_2, __v_5]; 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_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 __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_12, __v_14]; 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 __v_15: G = __r_arr[0];
     break '__mc_1 [__v_15];
   },
@@ -10785,11 +11360,11 @@ fn aiur_fn_108(
             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 __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_14, __v_1, __v_2, __v_8, __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 __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 __ret: [G; OUT_111] = [__v_17, __v_18];
+            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);
           },
           _ => {
@@ -10804,43 +11379,43 @@ fn aiur_fn_108(
   })
 }
 
-const INPUT_SIZE_109: usize = 5;
-const IN_109: usize = 5;
-const OUT_109: usize = 2;
-fn aiur_fn_109(
-  inp: [G; IN_109],
+const INPUT_SIZE_112: usize = 5;
+const IN_112: usize = 5;
+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_109], ExecError> {
+) -> Result<[G; OUT_112], ExecError> {
   stacker::maybe_grow(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 __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_1, __v_4]; 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_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 __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __v_0, __v_1, __v_3, __v_2, __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 __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)); };
+    let __ret: [G; OUT_112] = [__v_8, __v_9];
+    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);
   })
 }
 
-const INPUT_SIZE_110: usize = 6;
-const IN_110: usize = 6;
-const OUT_110: usize = 1;
-fn aiur_fn_110(
-  inp: [G; IN_110],
+const INPUT_SIZE_113: usize = 6;
+const IN_113: usize = 6;
+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_110], ExecError> {
+) -> Result<[G; OUT_113], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10848,32 +11423,32 @@ fn aiur_fn_110(
     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 __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1, __v_2, __v_5]; 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_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 __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6, __v_1, __v_2, __v_4, __v_3, __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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0, __v_10]; 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 __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)); };
+    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)); };
     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_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_111], ExecError> {
+) -> 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];
@@ -10883,17 +11458,17 @@ fn aiur_fn_111(
     let __v_4: G = __loaded[2];
     match __v_2.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 __ret: [G; OUT_114] = [__v_1];
+        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);
       },
       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 __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_4, __v_6]; 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 __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)); };
+        let __ret: [G; OUT_114] = [__v_7];
+        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);
       },
       _ => {
@@ -10903,15 +11478,15 @@ fn aiur_fn_111(
   })
 }
 
-const INPUT_SIZE_112: usize = 2;
-const IN_112: usize = 2;
-const OUT_112: usize = 1;
-fn aiur_fn_112(
-  inp: [G; IN_112],
+const INPUT_SIZE_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_112], ExecError> {
+) -> Result<[G; OUT_115], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10922,24 +11497,24 @@ fn aiur_fn_112(
     match __v_2.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_115] = [__v_5];
+        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);
       },
       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 __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5, __v_4]; 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_6: G = __r_arr[0];
         match __v_3.as_canonical_u64() {
           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 __ret: [G; OUT_115] = [__v_6];
+            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);
           },
           _ => {
             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)); };
+            let __ret: [G; OUT_115] = [__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)); };
             return Ok(__ret);
           },
         }
@@ -10951,15 +11526,15 @@ fn aiur_fn_112(
   })
 }
 
-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_116: usize = 8;
+const IN_116: usize = 8;
+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_113], ExecError> {
+) -> Result<[G; OUT_116], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10971,14 +11546,14 @@ fn aiur_fn_113(
     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 __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__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 __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 __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0, __v_13]; 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 __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 __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10, __v_14]; 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_15: G = __r_arr[0];
     let __v_16: G = (__v_15 + __v_15);
     let __v_17: G = (__v_4 + __v_6);
@@ -11060,50 +11635,50 @@ fn aiur_fn_113(
     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)); };
+    let __ret: [G; OUT_116] = [__v_82, __v_83];
+    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);
   })
 }
 
-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_117: usize = 2;
+const IN_117: usize = 2;
+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_114], ExecError> {
+) -> Result<[G; OUT_117], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     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 __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__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 __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 __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0, __v_6]; 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 __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 __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3, __v_7]; 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_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)); };
+    let __ret: [G; OUT_117] = [__v_9];
+    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);
   })
 }
 
-const INPUT_SIZE_115: usize = 8;
-const IN_115: usize = 8;
-const OUT_115: usize = 4;
-fn aiur_fn_115(
-  inp: [G; IN_115],
+const INPUT_SIZE_118: usize = 8;
+const IN_118: usize = 8;
+const OUT_118: usize = 4;
+fn aiur_fn_118(
+  inp: [G; IN_118],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_115], ExecError> {
+) -> Result<[G; OUT_118], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11126,8 +11701,8 @@ fn aiur_fn_115(
     let __v_17: G = __loaded[9];
     match __v_8.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 __ret: [G; OUT_118] = [__v_4, __v_5, __v_6, __v_7];
+        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)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -11180,13 +11755,13 @@ fn aiur_fn_115(
             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 __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__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[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_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)); };
+            let __ret: [G; OUT_118] = [__v_64, __v_65, __v_66, __v_67];
+            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)); };
             return Ok(__ret);
           },
           _ => {
@@ -11201,15 +11776,15 @@ fn aiur_fn_115(
   })
 }
 
-const INPUT_SIZE_116: usize = 2;
-const IN_116: usize = 2;
-const OUT_116: usize = 1;
-fn aiur_fn_116(
-  inp: [G; IN_116],
+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_116], ExecError> {
+) -> Result<[G; OUT_119], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11220,8 +11795,8 @@ fn aiur_fn_116(
     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)); };
+        let __ret: [G; OUT_119] = [__v_1];
+        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);
       },
       0u64 => {
@@ -11337,14 +11912,14 @@ fn aiur_fn_116(
         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 __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_5, __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 __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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __ret: [G; OUT_119] = [__v_98];
+        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);
       },
       _ => {
@@ -11354,15 +11929,15 @@ fn aiur_fn_116(
   })
 }
 
-const INPUT_SIZE_117: usize = 2;
-const IN_117: usize = 2;
-const OUT_117: usize = 1;
-fn aiur_fn_117(
-  inp: [G; IN_117],
+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_117], ExecError> {
+) -> Result<[G; OUT_120], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11372,17 +11947,17 @@ fn aiur_fn_117(
     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)); };
+        let __ret: [G; OUT_120] = [__v_1];
+        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);
       },
       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 __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_4, __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 __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 __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3, __v_5]; 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_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)); };
+        let __ret: [G; OUT_120] = [__v_6];
+        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);
       },
       _ => {
@@ -11392,15 +11967,15 @@ fn aiur_fn_117(
   })
 }
 
-const INPUT_SIZE_118: usize = 2;
-const IN_118: usize = 2;
-const OUT_118: usize = 1;
-fn aiur_fn_118(
-  inp: [G; IN_118],
+const INPUT_SIZE_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_118], ExecError> {
+) -> Result<[G; OUT_121], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11410,17 +11985,17 @@ fn aiur_fn_118(
     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)); };
+        let __ret: [G; OUT_121] = [__v_1];
+        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);
       },
       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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_4, __v_1]; 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_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 __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __v_5]; 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_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 __ret: [G; OUT_121] = [__v_6];
+        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);
       },
       _ => {
@@ -11430,30 +12005,30 @@ fn aiur_fn_118(
   })
 }
 
-const INPUT_SIZE_119: usize = 3;
-const IN_119: usize = 3;
-const OUT_119: usize = 1;
-fn aiur_fn_119(
-  inp: [G; IN_119],
+const INPUT_SIZE_122: usize = 3;
+const IN_122: usize = 3;
+const OUT_122: usize = 1;
+fn aiur_fn_122(
+  inp: [G; IN_122],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_119], ExecError> {
+) -> Result<[G; OUT_122], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     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)); };
+        let __ret: [G; OUT_122] = [__v_2];
+        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);
       },
       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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1, __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 __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)); };
+        let __ret: [G; OUT_122] = [__v_3];
+        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);
       },
       _ => {
@@ -11463,15 +12038,15 @@ 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_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_120], ExecError> {
+) -> Result<[G; OUT_123], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11481,8 +12056,8 @@ fn aiur_fn_120(
     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 __ret: [G; OUT_123] = [__v_0];
+        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);
       },
       0u64 => {
@@ -11494,12 +12069,12 @@ fn aiur_fn_120(
         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 __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__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[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 __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 __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_13, __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_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)); };
+        let __ret: [G; OUT_123] = [__v_14];
+        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);
       },
       _ => {
@@ -11509,15 +12084,15 @@ 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_124: usize = 10;
+const IN_124: usize = 10;
+const OUT_124: usize = 2;
+fn aiur_fn_124(
+  inp: [G; IN_124],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_121], ExecError> {
+) -> Result<[G; OUT_124], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11534,43 +12109,43 @@ fn aiur_fn_121(
         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)); };
+        let __ret: [G; OUT_124] = [__v_0, __v_12];
+        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);
       },
       _ => {
-        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 __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__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[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_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 __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_10, __v_13, __v_9]; 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 __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 __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_14]; 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_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)); };
+        let __ret: [G; OUT_124] = [__v_15, __v_16];
+        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);
       },
     }
   })
 }
 
-const INPUT_SIZE_122: usize = 4;
-const IN_122: usize = 4;
-const OUT_122: usize = 2;
-fn aiur_fn_122(
-  inp: [G; IN_122],
+const INPUT_SIZE_125: usize = 4;
+const IN_125: usize = 4;
+const OUT_125: usize = 2;
+fn aiur_fn_125(
+  inp: [G; IN_125],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_122], ExecError> {
+) -> Result<[G; OUT_125], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11585,8 +12160,8 @@ fn aiur_fn_122(
         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)); };
+        let __ret: [G; OUT_125] = [__v_9, __v_0];
+        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);
       },
       0u64 => {
@@ -11603,12 +12178,12 @@ fn aiur_fn_122(
         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 __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_0, __v_5]; 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 __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 __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__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[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_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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_18, __v_19]; 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_20: G = __r_arr[0];
             let __v_21: G = __r_arr[1];
             let __v_22: G = __r_arr[2];
@@ -11627,7 +12202,7 @@ fn aiur_fn_122(
             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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_36, __v_6, __v_16, __v_3]; 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_38: G = __r_arr[0];
             let __v_39: G = __r_arr[1];
             let __v_40: G = G::from_u64(0);
@@ -11674,8 +12249,8 @@ fn aiur_fn_122(
             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)); };
+            let __ret: [G; OUT_125] = [__v_83, __v_39];
+            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);
           },
           _ => {
@@ -11690,15 +12265,15 @@ fn aiur_fn_122(
   })
 }
 
-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_126: usize = 5;
+const IN_126: usize = 5;
+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_123], ExecError> {
+) -> Result<[G; OUT_126], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11708,12 +12283,12 @@ fn aiur_fn_123(
     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)); };
+        let __ret: [G; OUT_126] = [__v_5];
+        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_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_230] = { let __args: [G; IN_230] = [__v_0, __v_3]; 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 __v_5: G = __r_arr[0];
         let __v_6: G = (__v_1 - __v_4);
         let __v_7: G = (__v_5 + __v_6);
@@ -11721,8 +12296,8 @@ fn aiur_fn_123(
         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)); };
+            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)); };
             return Ok(__ret);
           },
           _ => {
@@ -11730,10 +12305,10 @@ fn aiur_fn_123(
             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 __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1, __v_10, __v_12, __v_4]; 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_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)); };
+            let __ret: [G; OUT_126] = [__v_13];
+            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);
           },
         }
@@ -11742,15 +12317,15 @@ fn aiur_fn_123(
   })
 }
 
-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_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_124], ExecError> {
+) -> Result<[G; OUT_127], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11761,22 +12336,22 @@ fn aiur_fn_124(
         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 __ret: [G; OUT_127] = [__v_6];
+        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)); };
         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 __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1, __v_2, __v_4, __v_3]; 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_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 __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_7]; 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_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)); };
+            let __ret: [G; OUT_127] = [__v_8];
+            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)); };
             return Ok(__ret);
           },
           _ => {
@@ -11787,11 +12362,11 @@ fn aiur_fn_124(
             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 __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_12]; 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_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)); };
+            let __ret: [G; OUT_127] = [__v_14];
+            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)); };
             return Ok(__ret);
           },
         }
@@ -11800,15 +12375,15 @@ fn aiur_fn_124(
   })
 }
 
-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_128: usize = 8;
+const IN_128: usize = 8;
+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_125], ExecError> {
+) -> Result<[G; OUT_128], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11831,8 +12406,8 @@ fn aiur_fn_125(
         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_128] = [__v_17];
+        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);
       },
       0u64 => {
@@ -11844,7 +12419,7 @@ fn aiur_fn_125(
               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 __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__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[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_19: G = __r_arr[0];
                 let __v_20: G = __r_arr[1];
                 let __v_21: G = __r_arr[2];
@@ -11861,17 +12436,17 @@ fn aiur_fn_125(
                 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)); };
+                let __ret: [G; OUT_128] = [__v_34];
+                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);
               },
               _ => {
                 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 __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__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[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_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)); };
+                let __ret: [G; OUT_128] = [__v_19];
+                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);
               },
             }
@@ -11885,15 +12460,15 @@ fn aiur_fn_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],
+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_126], ExecError> {
+) -> Result<[G; OUT_129], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11908,8 +12483,8 @@ fn aiur_fn_126(
     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_129] = [__v_9];
+        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);
       },
       0u64 => {
@@ -11931,15 +12506,15 @@ fn aiur_fn_126(
                   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)); };
+                let __ret: [G; OUT_129] = [__v_19];
+                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 __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 __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_8, __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 __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)); };
+                let __ret: [G; OUT_129] = [__v_11];
+                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);
               },
             }
@@ -11953,29 +12528,29 @@ 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_130: usize = 2;
+const IN_130: usize = 2;
+const OUT_130: usize = 1;
+fn aiur_fn_130(
+  inp: [G; IN_130],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_127], ExecError> {
+) -> Result<[G; OUT_130], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     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 __ret: [G; OUT_130] = [__v_2];
+        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)); };
         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)); };
+        let __ret: [G; OUT_130] = [__v_2];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -11985,15 +12560,15 @@ fn aiur_fn_127(
   })
 }
 
-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_131: usize = 10;
+const IN_131: usize = 10;
+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_128], ExecError> {
+) -> Result<[G; OUT_131], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12006,17 +12581,17 @@ fn aiur_fn_128(
     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 __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
     let __v_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 __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__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 __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 __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_11, __v_16]; 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 __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 __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_13, __v_17]; 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_18: G = __r_arr[0];
     let __v_19: G = (__v_12 * __v_18);
     let __v_20: G = G::from_u64(0);
@@ -12045,9 +12620,9 @@ fn aiur_fn_128(
     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 __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 __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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__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 __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));
@@ -12055,23 +12630,23 @@ fn aiur_fn_128(
     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_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 __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__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[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_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)); };
+    let __ret: [G; OUT_131] = [__v_45];
+    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_129: usize = 11;
-const IN_129: usize = 11;
-const OUT_129: usize = 1;
-fn aiur_fn_129(
-  inp: [G; IN_129],
+const INPUT_SIZE_132: usize = 11;
+const IN_132: usize = 11;
+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_129], ExecError> {
+) -> Result<[G; OUT_132], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12085,12 +12660,12 @@ fn aiur_fn_129(
     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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_8, __v_11]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_8, __v_13]; 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 __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 __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_4]; 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 __v_15: G = __r_arr[0];
     let __v_16: G = G::from_u64(0);
     let __v_17: G = (__v_5 * __v_15);
@@ -12101,25 +12676,25 @@ fn aiur_fn_129(
     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 __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__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[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_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 __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__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[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_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)); };
+    let __ret: [G; OUT_132] = [__v_26];
+    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);
   })
 }
 
-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_133: usize = 13;
+const IN_133: usize = 13;
+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_130], ExecError> {
+) -> Result<[G; OUT_133], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12136,43 +12711,43 @@ fn aiur_fn_130(
     let __v_12: G = inp[12];
     match __v_5.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 __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)); };
         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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_4]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_9, __v_4]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_10, __v_4]; 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 __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_132] = { let __args: [G; IN_132] = [__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[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_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 __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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[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_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 __ret: [G; OUT_133] = [__v_22];
+        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)); };
         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_134: usize = 13;
+const IN_134: usize = 13;
+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_131], ExecError> {
+) -> Result<[G; OUT_134], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12189,46 +12764,46 @@ fn aiur_fn_131(
     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 __ret: [G; OUT_134] = [__v_0];
+        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);
       },
       _ => {
-        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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_4]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_9, __v_4]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_10, __v_4]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_16, __v_17]; 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 __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 __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__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[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_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 __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__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[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_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)); };
+        let __ret: [G; OUT_134] = [__v_24];
+        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_132: usize = 15;
-const IN_132: usize = 15;
-const OUT_132: usize = 1;
-fn aiur_fn_132(
-  inp: [G; IN_132],
+const INPUT_SIZE_135: usize = 15;
+const IN_135: usize = 15;
+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_132], ExecError> {
+) -> Result<[G; OUT_135], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12247,12 +12822,12 @@ fn aiur_fn_132(
     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)); };
+        let __ret: [G; OUT_135] = [__v_0];
+        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);
       },
       _ => {
-        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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_8, __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 __v_15: G = __r_arr[0];
         let __v_16: G = __r_arr[1];
         match __v_15.as_canonical_u64() {
@@ -12261,21 +12836,21 @@ fn aiur_fn_132(
             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 __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__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[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_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)); };
+            let __ret: [G; OUT_135] = [__v_21];
+            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);
           },
           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_230] = { let __args: [G; IN_230] = [__v_7, __v_4]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_11, __v_6]; 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 __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_230] = { let __args: [G; IN_230] = [__v_12, __v_6]; 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 __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 __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__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[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 __v_22: G = G::from_u64(1);
             let __v_23: G = (__v_4 + __v_22);
@@ -12283,10 +12858,10 @@ fn aiur_fn_132(
             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 __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__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[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_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 __ret: [G; OUT_135] = [__v_28];
+            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);
           },
           _ => {
@@ -12298,15 +12873,15 @@ fn aiur_fn_132(
   })
 }
 
-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_136: usize = 15;
+const IN_136: usize = 15;
+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_133], ExecError> {
+) -> Result<[G; OUT_136], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12325,25 +12900,25 @@ fn aiur_fn_133(
     let __v_14: G = inp[14];
     match __v_3.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 __ret: [G; OUT_136] = [__v_0];
+        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_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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_1, __v_15]; 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 __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(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 __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_6, __v_10, __v_5, __v_7, __v_18]; 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_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 __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_19]; 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_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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_16]; 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 __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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4]; 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 __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));
@@ -12352,9 +12927,9 @@ fn aiur_fn_133(
               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 __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
             let __v_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 __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2, __v_16, __v_19, __v_27, __v_17, __v_20]; 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_28: G = __r_arr[0];
             let __v_29: G = G::from_u64(1);
             if (__v_28 != __v_29) {
@@ -12362,10 +12937,10 @@ fn aiur_fn_133(
             }
             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 __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__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[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_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 __ret: [G; OUT_136] = [__v_32];
+            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);
           },
         }
@@ -12377,15 +12952,15 @@ fn aiur_fn_133(
   })
 }
 
-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_137: usize = 4;
+const IN_137: usize = 4;
+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_134], ExecError> {
+) -> Result<[G; OUT_137], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12396,39 +12971,39 @@ fn aiur_fn_134(
         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 __ret: [G; OUT_137] = [__v_6];
+        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)); };
         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_230] = { let __args: [G; IN_230] = [__v_0, __v_3]; 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 __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 __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_8, __v_10]; 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 __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)); };
+        let __ret: [G; OUT_137] = [__v_12];
+        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)); };
         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],
+const INPUT_SIZE_138: usize = 1;
+const IN_138: usize = 1;
+const OUT_138: usize = 1;
+fn aiur_fn_138(
+  inp: [G; IN_138],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_135], ExecError> {
+) -> Result<[G; OUT_138], 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 };
@@ -12438,23 +13013,23 @@ fn aiur_fn_135(
     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)); };
+        let __ret: [G; OUT_138] = [__v_4];
+        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 __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 __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3]; 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_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 __ret: [G; OUT_138] = [__v_4];
+            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);
           },
           _ => {
-            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 __ret: [G; OUT_138] = [__v_2];
+            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);
           },
         }
@@ -12466,15 +13041,15 @@ fn aiur_fn_135(
   })
 }
 
-const INPUT_SIZE_136: usize = 5;
-const IN_136: usize = 5;
-const OUT_136: usize = 1;
-fn aiur_fn_136(
-  inp: [G; IN_136],
+const INPUT_SIZE_139: usize = 5;
+const IN_139: usize = 5;
+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_136], ExecError> {
+) -> Result<[G; OUT_139], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12486,12 +13061,12 @@ fn aiur_fn_136(
         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 __ret: [G; OUT_139] = [__v_7];
+        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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_2, __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 __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
         match __v_5.as_canonical_u64() {
@@ -12500,26 +13075,26 @@ fn aiur_fn_136(
             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 __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_8, __v_10]; 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_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)); };
+            let __ret: [G; OUT_139] = [__v_11];
+            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);
           },
           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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0, __v_4]; 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 __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 __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_11, __v_13]; 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_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)); };
+            let __ret: [G; OUT_139] = [__v_15];
+            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);
           },
           _ => {
@@ -12531,15 +13106,15 @@ fn aiur_fn_136(
   })
 }
 
-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_140: usize = 5;
+const IN_140: usize = 5;
+const OUT_140: usize = 4;
+fn aiur_fn_140(
+  inp: [G; IN_140],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_137], ExecError> {
+) -> Result<[G; OUT_140], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12548,28 +13123,28 @@ fn aiur_fn_137(
     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 __ret: [G; OUT_140] = [__v_1, __v_2, __v_3, __v_4];
+        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 __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)); };
+        let __ret: [G; OUT_140] = [__v_3, __v_4, __v_1, __v_2];
+        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);
       },
     }
   })
 }
 
-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_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_138], ExecError> {
+) -> Result<[G; OUT_141], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12810,21 +13385,21 @@ fn aiur_fn_138(
     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 __ret: [G; OUT_141] = [__v_194];
+    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);
   })
 }
 
-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_142: usize = 6;
+const IN_142: usize = 6;
+const OUT_142: usize = 3;
+fn aiur_fn_142(
+  inp: [G; IN_142],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_139], ExecError> {
+) -> Result<[G; OUT_142], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12842,8 +13417,8 @@ fn aiur_fn_139(
     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)); };
+        let __ret: [G; OUT_142] = [__v_0, __v_1, __v_5];
+        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);
       },
       0u64 => {
@@ -12854,7 +13429,7 @@ fn aiur_fn_139(
             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 __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__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_16: G = __r_arr[0];
                 let __v_17: G = __r_arr[1];
                 let __v_18: G = (__v_16 * __v_10);
@@ -12867,13 +13442,13 @@ fn aiur_fn_139(
                 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)); };
+                let __ret: [G; OUT_142] = [__v_26, __v_27, __v_12];
+                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);
               },
               _ => {
-                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)); };
+                let __ret: [G; OUT_142] = [__v_0, __v_1, __v_5];
+                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);
               },
             }
@@ -12887,15 +13462,15 @@ fn aiur_fn_139(
   })
 }
 
-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_143: usize = 9;
+const IN_143: usize = 9;
+const OUT_143: usize = 2;
+fn aiur_fn_143(
+  inp: [G; IN_143],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_140], ExecError> {
+) -> Result<[G; OUT_143], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12920,14 +13495,14 @@ fn aiur_fn_140(
         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 __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_7]; 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 __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)); };
+        let __ret: [G; OUT_143] = [__v_0, __v_1];
+        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)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -12955,7 +13530,7 @@ fn aiur_fn_140(
                         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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_11, __v_26]; 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 __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() {
@@ -13063,14 +13638,14 @@ fn aiur_fn_140(
                         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 __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__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[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_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 __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_105, __v_106, __v_25, __v_15, __v_16, __v_7]; 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_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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_11]; 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 __v_110: G = __r_arr[0];
                         let __v_111: G = G::from_u64(1);
                         if (__v_110 != __v_111) {
@@ -13229,17 +13804,17 @@ fn aiur_fn_140(
                         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 __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_19, __v_235, __v_240, __v_23, __v_12, __v_25]; 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_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 __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__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[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 __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)); };
+                        let __ret: [G; OUT_143] = [__v_243, __v_244];
+                        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)); };
                         return Ok(__ret);
                       },
                       _ => {
@@ -13266,15 +13841,15 @@ fn aiur_fn_140(
   })
 }
 
-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_144: usize = 25;
+const IN_144: usize = 25;
+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_141], ExecError> {
+) -> Result<[G; OUT_144], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13303,41 +13878,41 @@ fn aiur_fn_141(
     let __v_24: G = inp[24];
     match __v_1.as_canonical_u64() {
       _ => {
-        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 __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_15, __v_19, __v_18, __v_20]; 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_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 __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_15, __v_19, __v_18, __v_26]; 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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_1, __v_28]; 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 __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 __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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[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_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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_1, __v_33]; 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 __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 __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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[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_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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_1, __v_38]; 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 __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 __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__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[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_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 __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__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[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_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 __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_43, __v_19]; 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_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];
@@ -13351,14 +13926,14 @@ fn aiur_fn_141(
                       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 __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__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[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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_23, __v_54]; 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 __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 __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2]; 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 __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));
@@ -13366,10 +13941,10 @@ fn aiur_fn_141(
                             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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__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 __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 __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__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_63: G = __r_arr[0];
                             let __v_64: G = (__v_62 + __v_63);
                             let __v_65: G = (__v_61 - __v_64);
@@ -13378,7 +13953,7 @@ fn aiur_fn_141(
                             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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_29]; 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 __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));
@@ -13386,13 +13961,13 @@ fn aiur_fn_141(
                             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 __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10, __v_29, __v_27, __v_0, __v_30, __v_20]; 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_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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_34]; 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 __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));
@@ -13400,13 +13975,13 @@ fn aiur_fn_141(
                             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 __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_11, __v_34, __v_27, __v_0, __v_35, __v_20]; 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_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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_39]; 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 __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));
@@ -13414,7 +13989,7 @@ fn aiur_fn_141(
                             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 __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_12, __v_39, __v_27, __v_0, __v_40, __v_20]; 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_84: G = __r_arr[0];
                             let __v_85: G = G::from_u64(1);
                             if (__v_84 != __v_85) {
@@ -13436,8 +14011,8 @@ fn aiur_fn_141(
                               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)); };
+                            let __ret: [G; OUT_144] = [__v_95];
+                            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);
                           },
                         }
@@ -13457,15 +14032,15 @@ fn aiur_fn_141(
   })
 }
 
-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_145: usize = 25;
+const IN_145: usize = 25;
+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_142], ExecError> {
+) -> Result<[G; OUT_145], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13500,21 +14075,21 @@ fn aiur_fn_142(
     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)); };
+        let __ret: [G; OUT_145] = [__v_29];
+        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)); };
         return Ok(__ret);
       },
       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 __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_0, __v_1, __v_20]; 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 __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 __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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[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 __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 __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__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[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_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_145] = [__v_33];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -13524,15 +14099,15 @@ fn aiur_fn_142(
   })
 }
 
-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_146: usize = 31;
+const IN_146: usize = 31;
+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_143], ExecError> {
+) -> Result<[G; OUT_146], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13567,7 +14142,7 @@ fn aiur_fn_143(
     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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_6]; 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 __v_31: G = __r_arr[0];
         let __v_32: G = G::from_u64(1);
         let __v_33: G = G::from_u64(1);
@@ -13577,7 +14152,7 @@ fn aiur_fn_143(
     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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_5, __v_34]; 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_35: G = __r_arr[0];
     break '__mc_0 [__v_35];
   },
@@ -13587,18 +14162,18 @@ fn aiur_fn_143(
 }
  };
         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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3, __v_35]; 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_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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2, __v_36]; 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_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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1, __v_37]; 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_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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0, __v_38]; 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 __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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_39, __v_42]; 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_43: G = __r_arr[0];
         let __v_44: G = __r_arr[1];
         let __v_45: G = __r_arr[2];
@@ -13659,23 +14234,23 @@ fn aiur_fn_143(
         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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_59, __v_6, __v_7, __v_29]; 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_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 __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_9, __v_107]; 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_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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_104, __v_108]; 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 __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 __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_109, __v_6]; 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_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 __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__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[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_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 __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 __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));
@@ -13683,7 +14258,7 @@ fn aiur_fn_143(
         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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_8]; 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 __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));
@@ -13691,7 +14266,7 @@ fn aiur_fn_143(
         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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_9]; 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 __v_122: G = __r_arr[0];
         let __v_123: G = G::from_u64(1);
         if (__v_122 != __v_123) {
@@ -13703,46 +14278,46 @@ fn aiur_fn_143(
         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 __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__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[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_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)); };
+        let __ret: [G; OUT_146] = [__v_127];
+        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);
       },
     }
   })
 }
 
-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_147: usize = 2;
+const IN_147: usize = 2;
+const OUT_147: usize = 1;
+fn aiur_fn_147(
+  inp: [G; IN_147],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_144], ExecError> {
+) -> Result<[G; OUT_147], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     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)); };
+    let __ret: [G; OUT_147] = [__v_4];
+    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);
   })
 }
 
-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_148: usize = 1;
+const IN_148: usize = 1;
+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_145], ExecError> {
+) -> Result<[G; OUT_148], 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 };
@@ -13753,8 +14328,8 @@ fn aiur_fn_145(
     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 __ret: [G; OUT_148] = [__v_5];
+        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 => {
@@ -13768,15 +14343,15 @@ fn aiur_fn_145(
             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)); };
+            let __ret: [G; OUT_148] = [__v_11];
+            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);
           },
           _ => {
-            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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__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_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_148] = [__v_9];
+            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);
           },
         }
@@ -13788,15 +14363,15 @@ 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_149: usize = 9;
+const IN_149: usize = 9;
+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_146], ExecError> {
+) -> Result<[G; OUT_149], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13823,21 +14398,21 @@ fn aiur_fn_146(
     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)); };
+    let __ret: [G; OUT_149] = [__v_24];
+    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);
   })
 }
 
-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_150: usize = 33;
+const IN_150: usize = 33;
+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_147], ExecError> {
+) -> Result<[G; OUT_150], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13872,29 +14447,29 @@ fn aiur_fn_147(
     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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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)); };
+    let __ret: [G; OUT_150] = [__v_36];
+    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);
   })
 }
 
-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_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_148], ExecError> {
+) -> Result<[G; OUT_151], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13904,8 +14479,8 @@ fn aiur_fn_148(
     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)); };
+        let __ret: [G; OUT_151] = [__v_1];
+        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)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -13942,18 +14517,18 @@ fn aiur_fn_148(
         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 __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_4, __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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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)); };
+        let __ret: [G; OUT_151] = [__v_41];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -13963,15 +14538,15 @@ fn aiur_fn_148(
   })
 }
 
-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_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_149], ExecError> {
+) -> Result<[G; OUT_152], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13981,8 +14556,8 @@ fn aiur_fn_149(
     let __v_4: G = __loaded[2];
     match __v_2.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_152] = [__v_1];
+        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);
       },
       0u64 => {
@@ -13993,12 +14568,12 @@ fn aiur_fn_149(
         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 __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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)); };
+        let __ret: [G; OUT_152] = [__v_13];
+        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);
       },
       _ => {
@@ -14008,15 +14583,15 @@ fn aiur_fn_149(
   })
 }
 
-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_153: usize = 2;
+const IN_153: usize = 2;
+const OUT_153: usize = 10;
+fn aiur_fn_153(
+  inp: [G; IN_153],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_150], ExecError> {
+) -> Result<[G; OUT_153], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14076,9 +14651,9 @@ fn aiur_fn_150(
         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 __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; 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 __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 __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_55]; 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 __v_56: G = __r_arr[0];
         let __v_57: G = __r_arr[1];
         let __v_58: G = __r_arr[2];
@@ -14114,26 +14689,26 @@ fn aiur_fn_150(
         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 __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_84, __v_85, __v_86, __v_87, __v_90]; 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_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 __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_80, __v_81, __v_82, __v_83, __v_91]; 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_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 __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_76, __v_77, __v_78, __v_79, __v_92]; 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_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 __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_72, __v_73, __v_74, __v_75, __v_93]; 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_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 __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_68, __v_69, __v_70, __v_71, __v_94]; 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_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 __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_64, __v_65, __v_66, __v_67, __v_95]; 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_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 __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_60, __v_61, __v_62, __v_63, __v_96]; 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_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 __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_56, __v_57, __v_58, __v_59, __v_97]; 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_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 __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_98, __v_101]; 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 __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];
@@ -14183,8 +14758,8 @@ fn aiur_fn_150(
                                     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)); };
+                                        let __ret: [G; OUT_153] = [__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[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)); };
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -14270,8 +14845,8 @@ fn aiur_fn_150(
                                 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)); };
+                                    let __ret: [G; OUT_153] = [__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[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)); };
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -14316,19 +14891,19 @@ fn aiur_fn_150(
   })
 }
 
-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_154: usize = 2;
+const IN_154: usize = 2;
+const OUT_154: usize = 10;
+fn aiur_fn_154(
+  inp: [G; IN_154],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_151], ExecError> {
+) -> Result<[G; OUT_154], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    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 __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -14356,12 +14931,12 @@ fn aiur_fn_151(
     let __v_26: G = (__v_22 - __v_25);
     match __v_26.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 __ret: [G; OUT_154] = [__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[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 __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 __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_10, __v_11]; 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_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
         let __v_29: G = __r_arr[2];
@@ -14372,27 +14947,27 @@ fn aiur_fn_151(
         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)); };
+        let __ret: [G; OUT_154] = [__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[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);
       },
     }
   })
 }
 
-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_155: usize = 2;
+const IN_155: usize = 2;
+const OUT_155: usize = 18;
+fn aiur_fn_155(
+  inp: [G; IN_155],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_152], ExecError> {
+) -> Result<[G; OUT_155], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    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 __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -14403,7 +14978,7 @@ fn aiur_fn_152(
     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 __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_10, __v_11]; 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_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     let __v_14: G = __r_arr[2];
@@ -14414,21 +14989,21 @@ fn aiur_fn_152(
     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)); };
+    let __ret: [G; OUT_155] = [__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[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);
   })
 }
 
-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_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_153], ExecError> {
+) -> Result<[G; OUT_156], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14437,8 +15012,8 @@ fn aiur_fn_153(
         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 __ret: [G; OUT_156] = [__v_4];
+        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);
       },
       _ => {
@@ -14451,11 +15026,11 @@ fn aiur_fn_153(
             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)? } };
+            let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_4, __v_7]; 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_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 __ret: [G; OUT_156] = [__v_9];
+            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);
           },
           _ => {
@@ -14467,20 +15042,20 @@ fn aiur_fn_153(
   })
 }
 
-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_157: usize = 3;
+const IN_157: usize = 3;
+const OUT_157: usize = 3;
+fn aiur_fn_157(
+  inp: [G; IN_157],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_154], ExecError> {
+) -> Result<[G; OUT_157], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     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 __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_0, __v_1]; 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -14530,31 +15105,31 @@ fn aiur_fn_154(
     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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_51, __v_2]; 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_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)); };
+    let __ret: [G; OUT_157] = [__v_52, __v_11, __v_12];
+    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);
   })
 }
 
-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_158: usize = 9;
+const IN_158: usize = 9;
+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_155], ExecError> {
+) -> Result<[G; OUT_158], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14568,50 +15143,50 @@ fn aiur_fn_155(
     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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0, __v_12]; 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 __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)); };
+    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)); };
     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_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_156], ExecError> {
+) -> Result<[G; OUT_159], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     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 __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_1, __v_4]; 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_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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0, __v_5]; 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 __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)); };
+    let __ret: [G; OUT_159] = [__v_6];
+    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);
   })
 }
 
-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_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_157], ExecError> {
+) -> Result<[G; OUT_160], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -14656,21 +15231,21 @@ fn aiur_fn_157(
     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)); };
+    let __ret: [G; OUT_160] = [__v_42];
+    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);
   })
 }
 
-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_161: usize = 2;
+const IN_161: usize = 2;
+const OUT_161: usize = 1;
+fn aiur_fn_161(
+  inp: [G; IN_161],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_158], ExecError> {
+) -> Result<[G; OUT_161], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14687,17 +15262,17 @@ fn aiur_fn_158(
     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 __ret: [G; OUT_161] = [__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);
       },
       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 __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_11, __v_1]; 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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __ret: [G; OUT_161] = [__v_13];
+        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);
       },
       _ => {
@@ -14707,15 +15282,15 @@ 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_162: usize = 2;
+const IN_162: usize = 2;
+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_159], ExecError> {
+) -> Result<[G; OUT_162], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14724,13 +15299,13 @@ fn aiur_fn_159(
         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)); };
+        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)); };
         return Ok(__ret);
       },
       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 __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);
       },
       _ => {
@@ -14740,15 +15315,15 @@ fn aiur_fn_159(
   })
 }
 
-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_163: usize = 9;
+const IN_163: usize = 9;
+const OUT_163: usize = 9;
+fn aiur_fn_163(
+  inp: [G; IN_163],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_160], ExecError> {
+) -> Result<[G; OUT_163], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14759,15 +15334,15 @@ 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 __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_6, __v_7]; 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_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 __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_3, __v_9]; 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_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 __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_2, __v_10]; 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_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 __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_1, __v_11]; 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_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 __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __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 = G::from_u64(0);
     let __v_15: G = G::from_u64(109);
@@ -14814,7 +15389,7 @@ fn aiur_fn_160(
     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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_55, __v_58]; 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_59: G = __r_arr[0];
     let __v_60: G = __r_arr[1];
     let __v_61: G = __r_arr[2];
@@ -14836,16 +15411,16 @@ fn aiur_fn_160(
     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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_75, __v_81]; 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 __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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_82, __v_85]; 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_86: G = __r_arr[0];
     let __v_87: G = __r_arr[1];
     let __v_88: G = __r_arr[2];
@@ -14867,25 +15442,25 @@ fn aiur_fn_160(
     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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_102, __v_108]; 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 __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 __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_109, __v_4]; 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 __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 __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8, __v_113]; 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_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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_110, __v_114]; 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 __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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_115, __v_118]; 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_119: G = __r_arr[0];
     let __v_120: G = __r_arr[1];
     let __v_121: G = __r_arr[2];
@@ -14904,12 +15479,12 @@ fn aiur_fn_160(
     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 __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_135, __v_5]; 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 __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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_137, __v_140]; 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_141: G = __r_arr[0];
     let __v_142: G = __r_arr[1];
     let __v_143: G = __r_arr[2];
@@ -15096,29 +15671,29 @@ fn aiur_fn_160(
     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)); };
+    let __ret: [G; OUT_163] = [__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[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_161: usize = 3;
-const IN_161: usize = 3;
-const OUT_161: usize = 2;
-fn aiur_fn_161(
-  inp: [G; IN_161],
+const INPUT_SIZE_164: usize = 3;
+const IN_164: usize = 3;
+const OUT_164: usize = 2;
+fn aiur_fn_164(
+  inp: [G; IN_164],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_161], ExecError> {
+) -> Result<[G; OUT_164], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     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)); };
+        let __ret: [G; OUT_164] = [__v_0, __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);
       },
       _ => {
@@ -15132,135 +15707,135 @@ fn aiur_fn_161(
         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 __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_7, __v_10, __v_12]; 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_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)); };
+        let __ret: [G; OUT_164] = [__v_13, __v_14];
+        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);
       },
     }
   })
 }
 
-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_165: usize = 1;
+const IN_165: usize = 1;
+const OUT_165: usize = 1;
+fn aiur_fn_165(
+  inp: [G; IN_165],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_162], ExecError> {
+) -> Result<[G; OUT_165], 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_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)); };
+        let __ret: [G; OUT_165] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_165] = [__v_1];
+        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)); };
         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 __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_2]; 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 __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 __ret: [G; OUT_165] = [__v_4];
+        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)); };
         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],
+const INPUT_SIZE_166: usize = 3;
+const IN_166: usize = 3;
+const OUT_166: usize = 2;
+fn aiur_fn_166(
+  inp: [G; IN_166],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_163], ExecError> {
+) -> Result<[G; OUT_166], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     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 __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2]; 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_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)); };
+    let __ret: [G; OUT_166] = [__v_7, __v_8];
+    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_164: usize = 1;
-const IN_164: usize = 1;
-const OUT_164: usize = 1;
-fn aiur_fn_164(
-  inp: [G; IN_164],
+const INPUT_SIZE_167: usize = 1;
+const IN_167: usize = 1;
+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_164], ExecError> {
+) -> Result<[G; OUT_167], 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)); };
+        let __ret: [G; OUT_167] = [__v_1];
+        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)); };
         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 __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_3]; 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_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)); };
+        let __ret: [G; OUT_167] = [__v_5];
+        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)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-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_168: usize = 3;
+const IN_168: usize = 3;
+const OUT_168: usize = 8;
+fn aiur_fn_168(
+  inp: [G; IN_168],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_165], ExecError> {
+) -> Result<[G; OUT_168], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     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 __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2]; 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_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 __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_2]; 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 __v_9: G = __r_arr[0];
     let __v_10: G = g_inverse_value(__v_9);
     let __v_11: G = (__v_9 * __v_10);
@@ -15371,21 +15946,21 @@ fn aiur_fn_165(
     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 __ret: [G; OUT_168] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94];
+    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_166: usize = 23;
-const IN_166: usize = 23;
-const OUT_166: usize = 1;
-fn aiur_fn_166(
-  inp: [G; IN_166],
+const INPUT_SIZE_169: usize = 23;
+const IN_169: usize = 23;
+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_166], ExecError> {
+) -> Result<[G; OUT_169], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15412,52 +15987,52 @@ fn aiur_fn_166(
     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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__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 __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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_21]; 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 __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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_22]; 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 __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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_18]; 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 __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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__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_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)); };
+        let __ret: [G; OUT_169] = [__v_31];
+        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);
       },
     }
   })
 }
 
-const INPUT_SIZE_167: usize = 6;
-const IN_167: usize = 6;
-const OUT_167: usize = 2;
-fn aiur_fn_167(
-  inp: [G; IN_167],
+const INPUT_SIZE_170: usize = 6;
+const IN_170: usize = 6;
+const OUT_170: usize = 2;
+fn aiur_fn_170(
+  inp: [G; IN_170],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_167], ExecError> {
+) -> Result<[G; OUT_170], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15475,21 +16050,21 @@ fn aiur_fn_167(
     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 __ret: [G; OUT_170] = [__v_14, __v_15];
+    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);
   })
 }
 
-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_171: usize = 4;
+const IN_171: usize = 4;
+const OUT_171: usize = 2;
+fn aiur_fn_171(
+  inp: [G; IN_171],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_168], ExecError> {
+) -> Result<[G; OUT_171], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15507,21 +16082,21 @@ fn aiur_fn_168(
     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)); };
+    let __ret: [G; OUT_171] = [__v_14, __v_15];
+    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);
   })
 }
 
-const INPUT_SIZE_169: usize = 1;
-const IN_169: usize = 1;
-const OUT_169: usize = 1;
-fn aiur_fn_169(
-  inp: [G; IN_169],
+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_169], ExecError> {
+) -> Result<[G; OUT_172], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -15534,8 +16109,8 @@ fn aiur_fn_169(
         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_172] = [__v_7];
+        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);
       },
       0u64 => {
@@ -15547,14 +16122,14 @@ fn aiur_fn_169(
         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 __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__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_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 __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__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_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)); };
+            let __ret: [G; OUT_172] = [__v_13];
+            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);
           },
           _ => {
@@ -15569,15 +16144,15 @@ fn aiur_fn_169(
   })
 }
 
-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_173: usize = 15;
+const IN_173: usize = 15;
+const OUT_173: usize = 2;
+fn aiur_fn_173(
+  inp: [G; IN_173],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_170], ExecError> {
+) -> Result<[G; OUT_173], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15594,7 +16169,7 @@ fn aiur_fn_170(
     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 __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_0, __v_1]; 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 __v_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
     let __v_17: G = __r_arr[2];
@@ -15602,8 +16177,8 @@ fn aiur_fn_170(
     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)); };
+        let __ret: [G; OUT_173] = [__v_16, __v_19];
+        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);
       },
       1u64 => {
@@ -15611,109 +16186,109 @@ fn aiur_fn_170(
         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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4, __v_18]; 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 __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)); };
+            let __ret: [G; OUT_173] = [__v_21, __v_22];
+            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);
           },
           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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_5, __v_18]; 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 __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)); };
+            let __ret: [G; OUT_173] = [__v_21, __v_22];
+            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);
           },
           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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_2, __v_18]; 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 __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)); };
+            let __ret: [G; OUT_173] = [__v_21, __v_22];
+            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);
           },
           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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_3, __v_18]; 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 __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)); };
+            let __ret: [G; OUT_173] = [__v_21, __v_22];
+            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);
           },
           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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_6, __v_18]; 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 __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)); };
+            let __ret: [G; OUT_173] = [__v_21, __v_22];
+            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);
           },
           _ => {
-            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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_7, __v_18]; 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 __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)); };
+            let __ret: [G; OUT_173] = [__v_21, __v_22];
+            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);
           },
         }
       },
       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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_8, __v_16]; 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 __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)); };
+        let __ret: [G; OUT_173] = [__v_19, __v_20];
+        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);
       },
       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)); };
+        let __ret: [G; OUT_173] = [__v_9, __v_10];
+        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);
       },
       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)); };
+        let __ret: [G; OUT_173] = [__v_11, __v_12];
+        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);
       },
       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)); };
+        let __ret: [G; OUT_173] = [__v_13, __v_14];
+        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);
       },
       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 __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[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_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 __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[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_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_173] = [__v_23, __v_24];
+        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);
       },
       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 __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[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_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 __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[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_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_173] = [__v_23, __v_24];
+        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);
       },
       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 __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[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_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 __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[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_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = (__v_19 * __v_21);
@@ -15724,20 +16299,20 @@ fn aiur_fn_170(
         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)); };
+        let __ret: [G; OUT_173] = [__v_27, __v_30];
+        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);
       },
       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 __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[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_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)); };
+        let __ret: [G; OUT_173] = [__v_22, __v_24];
+        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);
       },
       _ => {
@@ -15747,15 +16322,15 @@ fn aiur_fn_170(
   })
 }
 
-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_174: usize = 19;
+const IN_174: usize = 19;
+const OUT_174: usize = 2;
+fn aiur_fn_174(
+  inp: [G; IN_174],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_171], ExecError> {
+) -> Result<[G; OUT_174], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15782,22 +16357,22 @@ fn aiur_fn_171(
     let __v_21: G = __loaded[2];
     match __v_19.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)); };
+        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 => {
-        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 __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__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 __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 __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__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_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 __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__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_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)); };
+        let __ret: [G; OUT_174] = [__v_26, __v_27];
+        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);
       },
       _ => {
@@ -15807,15 +16382,15 @@ fn aiur_fn_171(
   })
 }
 
-const INPUT_SIZE_172: usize = 8;
-const IN_172: usize = 8;
-const OUT_172: usize = 4;
-fn aiur_fn_172(
-  inp: [G; IN_172],
+const INPUT_SIZE_175: usize = 8;
+const IN_175: usize = 8;
+const OUT_175: usize = 4;
+fn aiur_fn_175(
+  inp: [G; IN_175],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_172], ExecError> {
+) -> Result<[G; OUT_175], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15871,21 +16446,21 @@ fn aiur_fn_172(
     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)); };
+    let __ret: [G; OUT_175] = [__v_50, __v_51, __v_52, __v_53];
+    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);
   })
 }
 
-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_176: usize = 19;
+const IN_176: usize = 19;
+const OUT_176: usize = 4;
+fn aiur_fn_176(
+  inp: [G; IN_176],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_173], ExecError> {
+) -> Result<[G; OUT_176], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15916,28 +16491,28 @@ fn aiur_fn_173(
         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)); };
+        let __ret: [G; OUT_176] = [__v_22, __v_23, __v_24, __v_25];
+        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)); };
         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 __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__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 __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 __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__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 __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 __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__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_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_176] = [__v_32, __v_33, __v_28, __v_29];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -15947,15 +16522,15 @@ fn aiur_fn_173(
   })
 }
 
-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_177: usize = 44;
+const IN_177: usize = 44;
+const OUT_177: usize = 2;
+fn aiur_fn_177(
+  inp: [G; IN_177],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_174], ExecError> {
+) -> Result<[G; OUT_177], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16008,14 +16583,14 @@ fn aiur_fn_174(
     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)); };
+        let __ret: [G; OUT_177] = [__v_0, __v_1];
+        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)); };
         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 __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__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 __v_48: G = __r_arr[0];
             let __v_49: G = __r_arr[1];
             let __v_50: G = __r_arr[2];
@@ -16024,10 +16599,10 @@ fn aiur_fn_174(
             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 __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__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_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 __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__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 __v_58: G = __r_arr[0];
             let __v_59: G = __r_arr[1];
             let __v_60: G = __r_arr[2];
@@ -16052,7 +16627,7 @@ fn aiur_fn_174(
             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 __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__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 __v_82: G = __r_arr[0];
             let __v_83: G = __r_arr[1];
             let __v_84: G = __r_arr[2];
@@ -16063,23 +16638,23 @@ fn aiur_fn_174(
             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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_35, __v_89]; 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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_35, __v_94]; 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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_36, __v_97]; 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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_36, __v_102]; 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 __v_103: G = __r_arr[0];
                 let __v_104: G = __r_arr[1];
                 let __v_105: G = (__v_103 + __v_20);
@@ -16088,23 +16663,23 @@ fn aiur_fn_174(
                 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 __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__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 __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 __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__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_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 __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__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_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)); };
+                let __ret: [G; OUT_177] = [__v_121, __v_122];
+                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)); };
                 return Ok(__ret);
               },
               _ => {
@@ -16113,44 +16688,44 @@ fn aiur_fn_174(
                 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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_35, __v_91]; 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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_35, __v_96]; 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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_35, __v_101]; 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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_35, __v_106]; 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 __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 __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__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 __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 __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__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_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 __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__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_123: G = __r_arr[0];
                     let __v_124: G = __r_arr[1];
                     let __v_125: G = G::from_u64(1);
@@ -16165,11 +16740,11 @@ fn aiur_fn_174(
                     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 __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__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_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)); };
+                    let __ret: [G; OUT_177] = [__v_137, __v_138];
+                    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)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -16177,11 +16752,11 @@ fn aiur_fn_174(
                     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 __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__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_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)); };
+                    let __ret: [G; OUT_177] = [__v_95, __v_96];
+                    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)); };
                     return Ok(__ret);
                   },
                 }
@@ -16197,15 +16772,15 @@ fn aiur_fn_174(
   })
 }
 
-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_178: usize = 28;
+const IN_178: usize = 28;
+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_175], ExecError> {
+) -> Result<[G; OUT_178], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16237,7 +16812,7 @@ fn aiur_fn_175(
     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 __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[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_30: G = __r_arr[0];
     let __v_31: G = __r_arr[1];
     let __v_32: G = G::from_u64(0);
@@ -16294,42 +16869,42 @@ fn aiur_fn_175(
     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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_9, __v_82]; 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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_8, __v_85]; 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 __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 __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; 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_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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_9, __v_94]; 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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_8, __v_97]; 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 __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 __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; 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_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)); };
+        let __ret: [G; OUT_178] = [__v_104, __v_105];
+        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);
       },
       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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_2]; 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 __v_83: G = __r_arr[0];
         let __v_84: G = G::from_u64(0);
         let __v_85: G = G::from_u64(1);
@@ -16340,11 +16915,11 @@ fn aiur_fn_175(
         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 __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__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[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_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)); };
+        let __ret: [G; OUT_178] = [__v_93, __v_94];
+        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);
       },
       _ => {
@@ -16354,15 +16929,15 @@ fn aiur_fn_175(
   })
 }
 
-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_179: usize = 8;
+const IN_179: usize = 8;
+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_176], ExecError> {
+) -> Result<[G; OUT_179], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16399,21 +16974,21 @@ fn aiur_fn_176(
     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 __ret: [G; OUT_179] = [__v_34];
+    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);
   })
 }
 
-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_180: usize = 5;
+const IN_180: usize = 5;
+const OUT_180: usize = 2;
+fn aiur_fn_180(
+  inp: [G; IN_180],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_177], ExecError> {
+) -> Result<[G; OUT_180], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16429,8 +17004,8 @@ fn aiur_fn_177(
       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_180] = [__v_9, __v_10];
+        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 => {
@@ -16450,13 +17025,13 @@ fn aiur_fn_177(
         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 __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__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_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 __ret: [G; OUT_180] = [__v_27, __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);
       },
       _ => {
@@ -16466,145 +17041,145 @@ fn aiur_fn_177(
   })
 }
 
-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_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_178], ExecError> {
+) -> Result<[G; OUT_181], 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_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 __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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)); };
+        let __ret: [G; OUT_181] = [__v_1];
+        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)); };
         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],
+const INPUT_SIZE_182: usize = 4;
+const IN_182: usize = 4;
+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_179], ExecError> {
+) -> Result<[G; OUT_182], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16618,8 +17193,8 @@ fn aiur_fn_179(
         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_182] = [__v_6, __v_9];
+        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);
       },
       1u64 => {
@@ -16631,21 +17206,21 @@ fn aiur_fn_179(
             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_182] = [__v_6, __v_9];
+            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);
           },
           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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_1, __v_3]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_4, __v_7]; 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 __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)); };
+            let __ret: [G; OUT_182] = [__v_6, __v_8];
+            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);
           },
           _ => {
@@ -16660,15 +17235,15 @@ fn aiur_fn_179(
   })
 }
 
-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_183: usize = 20;
+const IN_183: usize = 20;
+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_180], ExecError> {
+) -> Result<[G; OUT_183], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16702,37 +17277,37 @@ fn aiur_fn_180(
     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)); };
+        let __ret: [G; OUT_183] = [__v_28];
+        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);
       },
       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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_2, __v_9]; 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 __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 __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__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_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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_3, __v_9]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_4, __v_9]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_32, __v_33]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_32, __v_35]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_5, __v_9]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_37, __v_38]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_37, __v_40]; 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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_1, __v_9]; 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 __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() {
@@ -16757,13 +17332,13 @@ fn aiur_fn_180(
         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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7, __v_43]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_44, __v_45]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_44, __v_47]; 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 __v_48: G = __r_arr[0];
         break '__mc_0 [__v_46, __v_48];
       },
@@ -16779,14 +17354,14 @@ fn aiur_fn_180(
  };
             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 __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__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_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 __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__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 __v_52: G = __r_arr[0];
             let __v_53: G = g_inverse_value(__v_52);
             let __v_54: G = (__v_52 * __v_53);
@@ -16924,9 +17499,9 @@ fn aiur_fn_180(
             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 __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__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_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 __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__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 __v_166: G = __r_arr[0];
             let __v_167: G = (__v_165 * __v_166);
             let __v_168: G = g_inverse_value(__v_167);
@@ -16945,7 +17520,7 @@ fn aiur_fn_180(
             }
             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 __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__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[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_178: G = __r_arr[0];
             let __v_179: G = __r_arr[1];
             let __v_180: G = G::from_u64(0);
@@ -17002,40 +17577,40 @@ fn aiur_fn_180(
             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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_41, __v_230]; 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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_39, __v_233]; 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 __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 __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; 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_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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_41, __v_242]; 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 __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_39, __v_245]; 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 __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 __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; 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_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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_25]; 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 __v_231: G = __r_arr[0];
     let __v_232: G = G::from_u64(0);
     let __v_233: G = G::from_u64(1);
@@ -17046,7 +17621,7 @@ fn aiur_fn_180(
     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 __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__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[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_241: G = __r_arr[0];
     let __v_242: G = __r_arr[1];
     break '__mc_1 [__v_241, __v_242];
@@ -17058,19 +17633,19 @@ fn aiur_fn_180(
  };
             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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_8, __v_9]; 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 __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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_232, __v_233]; 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 __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 __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_234]; 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_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 __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__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_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 __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_235, __v_236, __v_237, __v_238, __v_239]; 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_240: G = __r_arr[0];
             let __v_241: G = __r_arr[1];
             let __v_242: G = (__v_230 * __v_134);
@@ -17087,7 +17662,7 @@ fn aiur_fn_180(
             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_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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_235]; 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 __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));
@@ -17106,10 +17681,10 @@ fn aiur_fn_180(
             }
             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 __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_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[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 __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)); };
+            let __ret: [G; OUT_183] = [__v_265];
+            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);
           },
         }
@@ -17121,15 +17696,15 @@ fn aiur_fn_180(
   })
 }
 
-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_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_181], ExecError> {
+) -> Result<[G; OUT_184], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17149,8 +17724,8 @@ fn aiur_fn_181(
       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 __ret: [G; OUT_184] = [__v_13, __v_14];
+        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 => {
@@ -17176,7 +17751,7 @@ fn aiur_fn_181(
         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 __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__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_35: G = __r_arr[0];
         let __v_36: G = __r_arr[1];
         let __v_37: G = (__v_0 * __v_35);
@@ -17189,8 +17764,8 @@ fn aiur_fn_181(
         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 __ret: [G; OUT_184] = [__v_45, __v_46];
+        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);
       },
       _ => {
@@ -17200,15 +17775,15 @@ fn aiur_fn_181(
   })
 }
 
-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_185: usize = 7;
+const IN_185: usize = 7;
+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_182], ExecError> {
+) -> Result<[G; OUT_185], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17223,12 +17798,12 @@ fn aiur_fn_182(
     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)); };
+        let __ret: [G; OUT_185] = [__v_0, __v_1];
+        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);
       },
       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 __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = (__v_3 + __v_10);
@@ -17258,11 +17833,11 @@ fn aiur_fn_182(
         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 __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__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_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)); };
+        let __ret: [G; OUT_185] = [__v_33, __v_34];
+        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);
       },
       _ => {
@@ -17272,15 +17847,15 @@ fn aiur_fn_182(
   })
 }
 
-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_186: usize = 37;
+const IN_186: usize = 37;
+const OUT_186: usize = 1;
+fn aiur_fn_186(
+  inp: [G; IN_186],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_183], ExecError> {
+) -> Result<[G; OUT_186], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17325,9 +17900,9 @@ fn aiur_fn_183(
           _ => {
             match __v_12.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 __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_8, __v_12]; 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_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 __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_11, __v_12]; 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 __v_38: G = __r_arr[0];
                 match __v_13.as_canonical_u64() {
                   _ => {
@@ -17347,15 +17922,15 @@ 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 __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_17, __v_36]; 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_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 __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_13, __v_40]; 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_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 __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_39, __v_41]; 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_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 __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_12, __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 __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 __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_7, __v_43]; 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_44: G = __r_arr[0];
                     let __v_45: G = G::from_u64(0);
                     let __v_46: G = G::from_u64(109);
@@ -17402,7 +17977,7 @@ fn aiur_fn_183(
                     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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_86, __v_89]; 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_90: G = __r_arr[0];
                     let __v_91: G = __r_arr[1];
                     let __v_92: G = __r_arr[2];
@@ -17424,16 +17999,16 @@ fn aiur_fn_183(
                     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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_106, __v_112]; 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 __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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_113, __v_116]; 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_117: G = __r_arr[0];
                     let __v_118: G = __r_arr[1];
                     let __v_119: G = __r_arr[2];
@@ -17455,25 +18030,25 @@ fn aiur_fn_183(
                     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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_133, __v_139]; 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 __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 __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_140, __v_14]; 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 __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 __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_16, __v_144]; 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_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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_141, __v_145]; 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 __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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_146, __v_149]; 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_150: G = __r_arr[0];
                     let __v_151: G = __r_arr[1];
                     let __v_152: G = __r_arr[2];
@@ -17492,12 +18067,12 @@ fn aiur_fn_183(
                     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 __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_166, __v_15]; 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 __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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_168, __v_171]; 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_172: G = __r_arr[0];
                     let __v_173: G = __r_arr[1];
                     let __v_174: G = __r_arr[2];
@@ -17686,17 +18261,17 @@ fn aiur_fn_183(
                     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 __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_358, __v_359, __v_35, __v_210, __v_231, __v_252, __v_273]; 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_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 __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__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[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 __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 __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_37]; 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_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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_18]; 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 __v_365: G = __r_arr[0];
                         let __v_366: G = G::from_u64(1);
                         let __v_367: G = G::from_u64(1);
@@ -17706,7 +18281,7 @@ fn aiur_fn_183(
     break '__mc_1 [__v_368];
   },
   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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_32, __v_368]; 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_369: G = __r_arr[0];
     break '__mc_1 [__v_369];
   },
@@ -17716,18 +18291,18 @@ fn aiur_fn_183(
 }
  };
                         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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_30, __v_369]; 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_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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_34, __v_370]; 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_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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_33, __v_371]; 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_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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_188, __v_372]; 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 __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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_373, __v_376]; 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_377: G = __r_arr[0];
                         let __v_378: G = __r_arr[1];
                         let __v_379: G = __r_arr[2];
@@ -17788,31 +18363,31 @@ fn aiur_fn_183(
                         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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_393, __v_18, __v_19, __v_5]; 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_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 __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_21, __v_441]; 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_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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_438, __v_442]; 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 __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 __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_443, __v_18]; 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_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 __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__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[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_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 __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_12]; 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 __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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_12]; 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 __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 __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_451: G = __r_arr[0];
                         let __v_452: G = (__v_450 - __v_451);
                         let __v_453: G = G::from_bool((__v_452 == G::ZERO));
@@ -17820,9 +18395,9 @@ fn aiur_fn_183(
                         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 __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_37]; 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_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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_16]; 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 __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));
@@ -17830,7 +18405,7 @@ fn aiur_fn_183(
                         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 __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_19]; 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 __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));
@@ -17838,7 +18413,7 @@ fn aiur_fn_183(
                         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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_20]; 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 __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));
@@ -17846,7 +18421,7 @@ fn aiur_fn_183(
                         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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_21]; 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 __v_468: G = __r_arr[0];
                         let __v_469: G = G::from_u64(1);
                         if (__v_468 != __v_469) {
@@ -17858,10 +18433,10 @@ fn aiur_fn_183(
                         if (__v_471 != __v_472) {
                           return Err(ExecError::AssertEqMismatch { lhs: __v_471.as_canonical_u64(), rhs: __v_472.as_canonical_u64(), msg: None });
                         }
-                        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 __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__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[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_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)); };
+                        let __ret: [G; OUT_186] = [__v_473];
+                        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);
                       },
                     }
@@ -17876,15 +18451,15 @@ 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_187: usize = 1;
+const IN_187: usize = 1;
+const OUT_187: usize = 1;
+fn aiur_fn_187(
+  inp: [G; IN_187],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_184], ExecError> {
+) -> Result<[G; OUT_187], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -17894,8 +18469,8 @@ fn aiur_fn_184(
     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)); };
+        let __ret: [G; OUT_187] = [__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);
       },
       0u64 => {
@@ -17906,10 +18481,10 @@ fn aiur_fn_184(
         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 __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__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 __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)); };
+        let __ret: [G; OUT_187] = [__v_8];
+        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);
       },
       _ => {
@@ -17919,15 +18494,15 @@ fn aiur_fn_184(
   })
 }
 
-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_188: usize = 2;
+const IN_188: usize = 2;
+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_185], ExecError> {
+) -> Result<[G; OUT_188], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17945,8 +18520,8 @@ fn aiur_fn_185(
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 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 __ret: [G; OUT_188] = [__v_12];
+        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);
       },
       0u64 => {
@@ -17958,19 +18533,19 @@ fn aiur_fn_185(
           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 __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__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_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)); };
+                let __ret: [G; OUT_188] = [__v_13];
+                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 __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 __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__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_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)); };
+                let __ret: [G; OUT_188] = [__v_15];
+                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);
               },
             }
@@ -17987,15 +18562,15 @@ fn aiur_fn_185(
   })
 }
 
-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_189: usize = 2;
+const IN_189: usize = 2;
+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_186], ExecError> {
+) -> Result<[G; OUT_189], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18009,8 +18584,8 @@ fn aiur_fn_186(
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_186] = [__v_8];
-        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_189] = [__v_8];
+        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)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -18022,19 +18597,19 @@ fn aiur_fn_186(
           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 __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__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 __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)); };
+                let __ret: [G; OUT_189] = [__v_9];
+                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)); };
                 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 __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__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 __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)); };
+                let __ret: [G; OUT_189] = [__v_11];
+                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)); };
                 return Ok(__ret);
               },
             }
@@ -18051,38 +18626,38 @@ fn aiur_fn_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],
+const INPUT_SIZE_190: usize = 1;
+const IN_190: usize = 1;
+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_187], ExecError> {
+) -> Result<[G; OUT_190], 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 __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; 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 __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 __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_2, __v_1]; 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 __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)); };
+    let __ret: [G; OUT_190] = [__v_3, __v_4];
+    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);
   })
 }
 
-const INPUT_SIZE_188: usize = 2;
-const IN_188: usize = 2;
-const OUT_188: usize = 2;
-fn aiur_fn_188(
-  inp: [G; IN_188],
+const INPUT_SIZE_191: usize = 2;
+const IN_191: usize = 2;
+const OUT_191: usize = 2;
+fn aiur_fn_191(
+  inp: [G; IN_191],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_188], ExecError> {
+) -> Result<[G; OUT_191], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18091,64 +18666,64 @@ fn aiur_fn_188(
         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)); };
+        let __ret: [G; OUT_191] = [__v_4, __v_0];
+        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)); };
         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 __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; 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 __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 __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_3, __v_2]; 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 __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 __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_5, __v_7]; 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 __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)); };
+        let __ret: [G; OUT_191] = [__v_11, __v_9];
+        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)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_189: usize = 1;
-const IN_189: usize = 1;
-const OUT_189: usize = 2;
-fn aiur_fn_189(
-  inp: [G; IN_189],
+const INPUT_SIZE_192: usize = 1;
+const IN_192: usize = 1;
+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_189], ExecError> {
+) -> Result<[G; OUT_192], 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 __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; 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 __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 __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_2, __v_1]; 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 __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)); };
+    let __ret: [G; OUT_192] = [__v_3, __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)); };
     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_193: usize = 2;
+const IN_193: usize = 2;
+const OUT_193: usize = 2;
+fn aiur_fn_193(
+  inp: [G; IN_193],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_190], ExecError> {
+) -> Result<[G; OUT_193], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18157,12 +18732,12 @@ fn aiur_fn_190(
         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)); };
+        let __ret: [G; OUT_193] = [__v_4, __v_0];
+        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)); };
         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 __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; 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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -18174,28 +18749,5597 @@ fn aiur_fn_190(
         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 __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__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 __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)); };
+        let __ret: [G; OUT_193] = [__v_16, __v_14];
+        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)); };
         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],
-  record: &mut QueryRecord,
+const INPUT_SIZE_194: usize = 1;
+const IN_194: usize = 1;
+const OUT_194: usize = 2;
+fn aiur_fn_194(
+  inp: [G; IN_194],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_194], 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() {
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            match __v_7.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_10: G = __loaded[0];
+                let __v_11: G = __loaded[1];
+                let __v_12: G = __loaded[2];
+                match __v_10.as_canonical_u64() {
+                  0u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_13: G = __loaded[0];
+                    let __v_14: G = __loaded[1];
+                    let __v_15: G = __loaded[2];
+                    match __v_13.as_canonical_u64() {
+                      0u64 => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_16: G = __loaded[0];
+                        let __v_17: G = __loaded[1];
+                        let __v_18: G = __loaded[2];
+                        match __v_16.as_canonical_u64() {
+                          0u64 => {
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_19: G = __loaded[0];
+                            let __v_20: G = __loaded[1];
+                            let __v_21: G = __loaded[2];
+                            match __v_19.as_canonical_u64() {
+                              0u64 => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_22: G = __loaded[0];
+                                let __v_23: G = __loaded[1];
+                                let __v_24: G = __loaded[2];
+                                match __v_22.as_canonical_u64() {
+                                  0u64 => {
+                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                    let __v_25: G = __loaded[0];
+                                    let __v_26: G = __loaded[1];
+                                    let __v_27: G = __loaded[2];
+                                    match __v_25.as_canonical_u64() {
+                                      0u64 => {
+                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                        let __v_28: G = __loaded[0];
+                                        let __v_29: G = __loaded[1];
+                                        let __v_30: G = __loaded[2];
+                                        match __v_28.as_canonical_u64() {
+                                          0u64 => {
+                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                            let __v_31: G = __loaded[0];
+                                            let __v_32: G = __loaded[1];
+                                            let __v_33: G = __loaded[2];
+                                            match __v_31.as_canonical_u64() {
+                                              0u64 => {
+                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                let __v_34: G = __loaded[0];
+                                                let __v_35: G = __loaded[1];
+                                                let __v_36: G = __loaded[2];
+                                                match __v_34.as_canonical_u64() {
+                                                  0u64 => {
+                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                    let __v_37: G = __loaded[0];
+                                                    let __v_38: G = __loaded[1];
+                                                    let __v_39: G = __loaded[2];
+                                                    match __v_37.as_canonical_u64() {
+                                                      0u64 => {
+                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                        let __v_40: G = __loaded[0];
+                                                        let __v_41: G = __loaded[1];
+                                                        let __v_42: G = __loaded[2];
+                                                        match __v_40.as_canonical_u64() {
+                                                          0u64 => {
+                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                            let __v_43: G = __loaded[0];
+                                                            let __v_44: G = __loaded[1];
+                                                            let __v_45: G = __loaded[2];
+                                                            match __v_43.as_canonical_u64() {
+                                                              0u64 => {
+                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                let __v_46: G = __loaded[0];
+                                                                let __v_47: G = __loaded[1];
+                                                                let __v_48: G = __loaded[2];
+                                                                match __v_46.as_canonical_u64() {
+                                                                  0u64 => {
+                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                    let __v_49: G = __loaded[0];
+                                                                    let __v_50: G = __loaded[1];
+                                                                    let __v_51: G = __loaded[2];
+                                                                    match __v_49.as_canonical_u64() {
+                                                                      0u64 => {
+                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                        let __v_52: G = __loaded[0];
+                                                                        let __v_53: G = __loaded[1];
+                                                                        let __v_54: G = __loaded[2];
+                                                                        match __v_52.as_canonical_u64() {
+                                                                          0u64 => {
+                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                            let __v_55: G = __loaded[0];
+                                                                            let __v_56: G = __loaded[1];
+                                                                            let __v_57: G = __loaded[2];
+                                                                            match __v_55.as_canonical_u64() {
+                                                                              0u64 => {
+                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                let __v_58: G = __loaded[0];
+                                                                                let __v_59: G = __loaded[1];
+                                                                                let __v_60: G = __loaded[2];
+                                                                                match __v_58.as_canonical_u64() {
+                                                                                  0u64 => {
+                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                    let __v_61: G = __loaded[0];
+                                                                                    let __v_62: G = __loaded[1];
+                                                                                    let __v_63: G = __loaded[2];
+                                                                                    match __v_61.as_canonical_u64() {
+                                                                                      0u64 => {
+                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                        let __v_64: G = __loaded[0];
+                                                                                        let __v_65: G = __loaded[1];
+                                                                                        let __v_66: G = __loaded[2];
+                                                                                        match __v_64.as_canonical_u64() {
+                                                                                          0u64 => {
+                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                            let __v_67: G = __loaded[0];
+                                                                                            let __v_68: G = __loaded[1];
+                                                                                            let __v_69: G = __loaded[2];
+                                                                                            match __v_67.as_canonical_u64() {
+                                                                                              0u64 => {
+                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                let __v_70: G = __loaded[0];
+                                                                                                let __v_71: G = __loaded[1];
+                                                                                                let __v_72: G = __loaded[2];
+                                                                                                match __v_70.as_canonical_u64() {
+                                                                                                  0u64 => {
+                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                    let __v_73: G = __loaded[0];
+                                                                                                    let __v_74: G = __loaded[1];
+                                                                                                    let __v_75: G = __loaded[2];
+                                                                                                    match __v_73.as_canonical_u64() {
+                                                                                                      0u64 => {
+                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                        let __v_76: G = __loaded[0];
+                                                                                                        let __v_77: G = __loaded[1];
+                                                                                                        let __v_78: G = __loaded[2];
+                                                                                                        match __v_76.as_canonical_u64() {
+                                                                                                          0u64 => {
+                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                            let __v_79: G = __loaded[0];
+                                                                                                            let __v_80: G = __loaded[1];
+                                                                                                            let __v_81: G = __loaded[2];
+                                                                                                            match __v_79.as_canonical_u64() {
+                                                                                                              0u64 => {
+                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                let __v_82: G = __loaded[0];
+                                                                                                                let __v_83: G = __loaded[1];
+                                                                                                                let __v_84: G = __loaded[2];
+                                                                                                                match __v_82.as_canonical_u64() {
+                                                                                                                  0u64 => {
+                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                    let __v_85: G = __loaded[0];
+                                                                                                                    let __v_86: G = __loaded[1];
+                                                                                                                    let __v_87: G = __loaded[2];
+                                                                                                                    match __v_85.as_canonical_u64() {
+                                                                                                                      0u64 => {
+                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                        let __v_88: G = __loaded[0];
+                                                                                                                        let __v_89: G = __loaded[1];
+                                                                                                                        let __v_90: G = __loaded[2];
+                                                                                                                        match __v_88.as_canonical_u64() {
+                                                                                                                          0u64 => {
+                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                            let __v_91: G = __loaded[0];
+                                                                                                                            let __v_92: G = __loaded[1];
+                                                                                                                            let __v_93: G = __loaded[2];
+                                                                                                                            match __v_91.as_canonical_u64() {
+                                                                                                                              0u64 => {
+                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                let __v_94: G = __loaded[0];
+                                                                                                                                let __v_95: G = __loaded[1];
+                                                                                                                                let __v_96: G = __loaded[2];
+                                                                                                                                match __v_94.as_canonical_u64() {
+                                                                                                                                  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_194] = [__v_97, __v_96];
+                                                                                                                                    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)); };
+                                                                                                                                    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_195: usize = 2;
+const IN_195: usize = 2;
+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 __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 = __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_46: G = G::from_u64(0);
+    let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_48: G = G::from_u64(0);
+    let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_50: G = G::from_u64(0);
+    let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_52: G = G::from_u64(0);
+    let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_54: G = G::from_u64(0);
+    let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_56: G = G::from_u64(0);
+    let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_58: G = G::from_u64(0);
+    let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_60: G = G::from_u64(0);
+    let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_62: G = G::from_u64(0);
+    let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_64: G = G::from_u64(0);
+    let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_66: G = G::from_u64(0);
+    let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_68: G = G::from_u64(0);
+    let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_70: G = G::from_u64(0);
+    let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_72: G = G::from_u64(0);
+    let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_74: G = G::from_u64(0);
+    let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_76: G = G::from_u64(0);
+    let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_78: G = G::from_u64(0);
+    let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_80: G = G::from_u64(0);
+    let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_82: G = G::from_u64(0);
+    let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_84: G = G::from_u64(0);
+    let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_86: G = G::from_u64(0);
+    let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_88: G = G::from_u64(0);
+    let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_90: G = G::from_u64(0);
+    let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_92: G = G::from_u64(0);
+    let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_94: G = G::from_u64(0);
+    let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_96: G = G::from_u64(0);
+    let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_195] = [__v_97];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_196: usize = 1;
+const IN_196: usize = 1;
+const OUT_196: usize = 8;
+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 __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 __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_196] = [__v_41, __v_50, __v_59, __v_68, __v_77, __v_86, __v_95, __v_104];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_197: usize = 2;
+const IN_197: usize = 2;
+const OUT_197: usize = 1;
+fn aiur_fn_197(
+  inp: [G; IN_197],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_197], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(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_195] = { let __args: [G; IN_195] = [__v_1, __v_4]; 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_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_0, __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(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_65] = { let __args: [G; IN_65] = [__v_9]; 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_10: G = __r_arr[0];
+    let __ret: [G; OUT_197] = [__v_10];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_198: usize = 1;
+const IN_198: usize = 1;
+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 __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_195] = { let __args: [G; IN_195] = [__v_0, __v_3]; 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_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_65] = { let __args: [G; IN_65] = [__v_7]; 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_8: G = __r_arr[0];
+    let __ret: [G; OUT_198] = [__v_8];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_199: usize = 4;
+const IN_199: usize = 4;
+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 __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_199] = [__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)); };
+    return Ok(__ret);
+  })
+}
+
+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 __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 = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __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_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_200] = [__v_218];
+                                    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);
+                                  },
+                                  _ => {
+                                    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_200] = [__v_219];
+                                        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);
+                                      },
+                                      _ => {
+                                        let __v_219: G = G::from_u64(2);
+                                        let __ret: [G; OUT_200] = [__v_219];
+                                        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);
+                                      },
+                                    }
+                                  },
+                                }
+                              },
+                              _ => {
+                                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_200] = [__v_200];
+                                    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);
+                                  },
+                                  _ => {
+                                    let __v_200: G = G::from_u64(2);
+                                    let __ret: [G; OUT_200] = [__v_200];
+                                    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);
+                                  },
+                                }
+                              },
+                            }
+                          },
+                          _ => {
+                            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_200] = [__v_181];
+                                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);
+                              },
+                              _ => {
+                                let __v_181: G = G::from_u64(2);
+                                let __ret: [G; OUT_200] = [__v_181];
+                                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);
+                              },
+                            }
+                          },
+                        }
+                      },
+                      _ => {
+                        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_200] = [__v_162];
+                            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);
+                          },
+                          _ => {
+                            let __v_162: G = G::from_u64(2);
+                            let __ret: [G; OUT_200] = [__v_162];
+                            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);
+                          },
+                        }
+                      },
+                    }
+                  },
+                  _ => {
+                    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_200] = [__v_143];
+                        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);
+                      },
+                      _ => {
+                        let __v_143: G = G::from_u64(2);
+                        let __ret: [G; OUT_200] = [__v_143];
+                        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);
+                      },
+                    }
+                  },
+                }
+              },
+              _ => {
+                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_200] = [__v_124];
+                    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);
+                  },
+                  _ => {
+                    let __v_124: G = G::from_u64(2);
+                    let __ret: [G; OUT_200] = [__v_124];
+                    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);
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            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_200] = [__v_105];
+                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);
+              },
+              _ => {
+                let __v_105: G = G::from_u64(2);
+                let __ret: [G; OUT_200] = [__v_105];
+                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);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        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_200] = [__v_86];
+            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);
+          },
+          _ => {
+            let __v_86: G = G::from_u64(2);
+            let __ret: [G; OUT_200] = [__v_86];
+            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);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_201: usize = 1;
+const IN_201: usize = 1;
+const OUT_201: usize = 0;
+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 __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 __ret: [G; OUT_201] = [];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_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_201] = [];
+            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)); };
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_2, __v_5]; 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_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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__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 __ret: [G; OUT_201] = [];
+            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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.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 __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 __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_194] = { let __args: [G; IN_194] = [__v_2]; 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_9, __v_4];
+        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)); };
+        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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_5, __v_2];
+        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)); };
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__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_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_3, __v_5]; 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 __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_202] = [__v_7, __v_6];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_203: usize = 1;
+const IN_203: usize = 1;
+const OUT_203: usize = 1;
+fn aiur_fn_203(
+  inp: [G; IN_203],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_203], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(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_203] = [__v_6];
+        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 __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_7];
+        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);
+      },
+      _ => {
+        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(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_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);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_2, __v_39]; 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_41: G = __r_arr[0];
+            let __v_42: G = G::from_u64(1);
+            let __v_43: G = G::from_u64(1);
+            let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_45: G = { let __values: [G; 3] = [__v_40, __v_41, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_204] = [__v_45];
+            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 __v_7: G = G::from_u64(0);
+            let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_2, __v_5]; 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_8: G = __r_arr[0];
+            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_9: G = __r_arr[0];
+            let __v_10: G = { let __values: [G; 3] = [__v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_204] = [__v_10];
+            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_4.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_205: usize = 1;
+const IN_205: usize = 1;
+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_205], 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() {
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_205] = [__v_2];
+            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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0]; 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_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7]; 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_8: G = __r_arr[0];
+            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)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_206: usize = 1;
+const IN_206: usize = 1;
+const OUT_206: usize = 1;
+fn aiur_fn_206(
+  inp: [G; IN_206],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_206], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__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_1: G = __r_arr[0];
+    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__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 __ret: [G; OUT_206] = [__v_2];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_207: usize = 1;
+const IN_207: usize = 1;
+const OUT_207: usize = 1;
+fn aiur_fn_207(
+  inp: [G; IN_207],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_207], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = 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 __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_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 __v_37: G = __r_arr[0];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_37]; 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_38: G = __r_arr[0];
+    let __v_39: G = __r_arr[1];
+    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__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_40: G = __r_arr[0];
+    let __v_41: G = __r_arr[1];
+    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 __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_40]; 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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_44: G = __loaded[0];
+    let __v_45: G = __loaded[1];
+    let __v_46: G = __loaded[2];
+    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_231] = { let __args: [G; IN_231] = [__v_40]; 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 __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_1] = { let __args: [G; IN_1] = [__v_42, __v_0]; 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 __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_207] = [__v_40];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_208: usize = 2;
+const IN_208: usize = 2;
+const OUT_208: usize = 1;
+fn aiur_fn_208(
+  inp: [G; IN_208],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_208], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_4];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1]; 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 __v_2: G = __r_arr[0];
+        let __ret: [G; OUT_208] = [__v_2];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_209: usize = 2;
+const IN_209: usize = 2;
+const OUT_209: usize = 0;
+fn aiur_fn_209(
+  inp: [G; IN_209],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_209], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = 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];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_5: G = __loaded[0];
+    let __v_6: G = __loaded[1];
+    let __v_7: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_209] = [];
+            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)); };
+            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_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 __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_209] = { let __args: [G; IN_209] = [__v_4, __v_7]; 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 __ret: [G; OUT_209] = [];
+            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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_210: usize = 3;
+const IN_210: usize = 3;
+const OUT_210: usize = 0;
+fn aiur_fn_210(
+  inp: [G; IN_210],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_210], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    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_3.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_1, __v_2]; 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 __ret: [G; OUT_210] = [];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_0, __v_2]; 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 __ret: [G; OUT_210] = [];
+            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)); };
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_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_200] = { let __args: [G; IN_200] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__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_12: G = __r_arr[0];
+                match __v_12.as_canonical_u64() {
+                  0u64 => {
+                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __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 __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_210] = { let __args: [G; IN_210] = [__v_5, __v_1, __v_11]; 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 __ret: [G; OUT_210] = [];
+                    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)); };
+                    return Ok(__ret);
+                  },
+                  1u64 => {
+                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __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 __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_210] = { let __args: [G; IN_210] = [__v_5, __v_8, __v_11]; 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 __ret: [G; OUT_210] = [];
+                    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)); };
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    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 __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_210] = { let __args: [G; IN_210] = [__v_0, __v_8, __v_11]; 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 __ret: [G; OUT_210] = [];
+                    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)); };
+                    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_211: usize = 2;
+const IN_211: usize = 2;
+const OUT_211: usize = 4;
+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 __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];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_5: G = __loaded[0];
+    let __v_6: G = __loaded[1];
+    let __v_7: G = __loaded[2];
+    match __v_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_211] = [__v_8, __v_9, __v_9, __v_9];
+            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)); };
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_211] = [__v_8, __v_6, __v_0, __v_7];
+            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)); };
+            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_211] = [__v_8, __v_3, __v_4, __v_1];
+            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)); };
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__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];
+            match __v_8.as_canonical_u64() {
+              0u64 => {
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_211] = [__v_9, __v_3, __v_4, __v_1];
+                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)); };
+                return Ok(__ret);
+              },
+              1u64 => {
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_211] = [__v_9, __v_3, __v_4, __v_7];
+                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)); };
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_211] = [__v_9, __v_6, __v_0, __v_7];
+                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)); };
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_212: usize = 2;
+const IN_212: usize = 2;
+const OUT_212: usize = 2;
+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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_212] = [__v_5, __v_1];
+        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)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3, __v_0]; 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_5: G = __r_arr[0];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_4]; 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 __v_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __ret: [G; OUT_212] = [__v_6, __v_7];
+            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)); };
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __ret: [G; OUT_212] = [__v_6, __v_4];
+            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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_6: G = G::from_u64(0);
+            let __ret: [G; OUT_212] = [__v_6, __v_1];
+            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)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_213: usize = 4;
+const IN_213: usize = 4;
+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 __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_211] = { let __args: [G; IN_211] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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];
+        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_213] = [];
+        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)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_5, __v_2]; 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 __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_213] = { let __args: [G; IN_213] = [__v_6, __v_7, __v_9, __v_3]; 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 __ret: [G; OUT_213] = [];
+            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)); };
+            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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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 => {
+                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_5, __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 __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_213] = { let __args: [G; IN_213] = [__v_6, __v_7, __v_9, __v_12]; 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 __ret: [G; OUT_213] = [];
+                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)); };
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_214: usize = 3;
+const IN_214: usize = 3;
+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 __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_214] = [__v_0, __v_2];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; 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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__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];
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() {
+  0u64 => {
+    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_5, __v_0]; 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_7: G = __r_arr[0];
+    break '__mc_0 [__v_7];
+  },
+  _ => {
+    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0, __v_5]; 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_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_214] = { let __args: [G; IN_214] = [__v_7, __v_12, __v_6]; 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 __v_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __ret: [G; OUT_214] = [__v_13, __v_14];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_215: usize = 2;
+const IN_215: usize = 2;
+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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    let __v_9: G = __loaded[6];
+    let __v_10: G = __loaded[7];
+    let __v_11: G = __loaded[8];
+    let __v_12: G = __loaded[9];
+    let __v_13: G = __loaded[10];
+    let __v_14: G = __loaded[11];
+    let __v_15: G = __loaded[12];
+    let __v_16: G = __loaded[13];
+    let __v_17: G = __loaded[14];
+    let __v_18: G = __loaded[15];
+    let __v_19: G = __loaded[16];
+    let __v_20: G = __loaded[17];
+    let __v_21: G = __loaded[18];
+    let __v_22: G = __loaded[19];
+    let __v_23: G = __loaded[20];
+    let __v_24: G = __loaded[21];
+    let __v_25: G = __loaded[22];
+    let __v_26: G = __loaded[23];
+    let __v_27: G = __loaded[24];
+    let __v_28: G = __loaded[25];
+    let __v_29: G = __loaded[26];
+    let __v_30: G = __loaded[27];
+    let __v_31: G = __loaded[28];
+    let __v_32: G = __loaded[29];
+    let __v_33: G = __loaded[30];
+    let __v_34: G = __loaded[31];
+    let __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_2] = { let __args: [G; IN_2] = [__v_37, __v_35, __v_36]; 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 __v_38: G = __r_arr[0];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; 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_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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_44: G = __loaded[0];
+        let __v_45: G = __loaded[1];
+        let __v_46: G = __loaded[2];
+        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_215] = [__v_49];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        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 __v_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__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_46: G = __r_arr[0];
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_46, __v_44, __v_45]; 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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_52: G = __loaded[0];
+        let __v_53: G = __loaded[1];
+        let __v_54: G = __loaded[2];
+        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_1] = { let __args: [G; IN_1] = [__v_47, __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 __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_215] = [__v_59];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_216: usize = 4;
+const IN_216: usize = 4;
+const OUT_216: usize = 0;
+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 __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_211] = { let __args: [G; IN_211] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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];
+        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_216] = [];
+        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)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_5, __v_2]; 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 __v_8: G = __r_arr[0];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_6, __v_7, __v_2, __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 __ret: [G; OUT_216] = [];
+            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)); };
+            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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_5, __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 __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_216] = { let __args: [G; IN_216] = [__v_6, __v_7, __v_2, __v_11]; 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 __ret: [G; OUT_216] = [];
+                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)); };
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_217: usize = 1;
+const IN_217: usize = 1;
+const OUT_217: usize = 3;
+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 __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 __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_217] = [__v_3, __v_4, __v_2];
+        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)); };
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_2]; 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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_217] = [__v_5, __v_3, __v_4];
+        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)); };
+        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 = 3;
+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 __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 __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_2]; 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_4]; 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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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];
+    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_218] = [__v_3, __v_5, __v_6];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_219: usize = 8;
+const IN_219: usize = 8;
+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 __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_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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_48: G = G::from_u64(0);
+    let __v_49: G = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_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_68] = { let __args: [G; IN_68] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; 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 __v_63: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_63]; 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 __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_219] = [__v_12];
+    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)); };
+    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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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 __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_220] = [__v_30];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_221: usize = 2;
+const IN_221: usize = 2;
+const OUT_221: usize = 8;
+fn aiur_fn_221(
+  inp: [G; IN_221],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_221], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0, __v_1]; 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 __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_220] = { let __args: [G; IN_220] = [__v_0, __v_4]; 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 __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_220] = { let __args: [G; IN_220] = [__v_0, __v_7]; 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 __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_220] = { let __args: [G; IN_220] = [__v_0, __v_10]; 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 __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_220] = { let __args: [G; IN_220] = [__v_0, __v_13]; 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 __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_220] = { let __args: [G; IN_220] = [__v_0, __v_16]; 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 __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_220] = { let __args: [G; IN_220] = [__v_0, __v_19]; 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 __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_220] = { let __args: [G; IN_220] = [__v_0, __v_22]; 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 __v_23: G = __r_arr[0];
+    let __ret: [G; OUT_221] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_222: usize = 16;
+const IN_222: usize = 16;
+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 __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_222] = [];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+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_223], 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() {
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        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()) });
+        }
+        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()) });
+        }
+        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_223] = [__v_2];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_224: usize = 13;
+const IN_224: usize = 13;
+const OUT_224: usize = 1;
+fn aiur_fn_224(
+  inp: [G; IN_224],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_224], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __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_29] = { let __args: [G; IN_29] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_16: G = __r_arr[0];
+    let __v_17: G = __r_arr[1];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_17, __v_16]; 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_18: G = __r_arr[0];
+    let __v_19: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19]; 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 __v_20: G = __r_arr[0];
+    let __v_21: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_21]; 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 __v_22: G = __r_arr[0];
+    let __v_23: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_23]; 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 __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 __v_26: G = __r_arr[0];
+    let __v_27: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_28: G = __r_arr[0];
+    let __v_29: G = __r_arr[1];
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_29, __v_28]; 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_30: G = __r_arr[0];
+    let __v_31: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_32: G = __r_arr[0];
+    let __v_33: G = __r_arr[1];
+    let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_33, __v_32]; 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 __v_34: G = __r_arr[0];
+    let __v_35: G = __r_arr[1];
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_35]; 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_36: G = __r_arr[0];
+    let __v_37: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_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, __v_38]; 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 __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_41]; 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_42: G = __r_arr[0];
+    let __v_43: G = __r_arr[1];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_43]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+    let __v_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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_52]; 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 __v_53: G = __r_arr[0];
+    let __v_54: G = __r_arr[1];
+    let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_54]; 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 __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_44] = { let __args: [G; IN_44] = [__v_57]; 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 __v_58: G = __r_arr[0];
+    let __v_59: G = __r_arr[1];
+    let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_59]; 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 __v_60: G = __r_arr[0];
+    let __v_61: G = __r_arr[1];
+    let __v_62: G = G::from_u64(2);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_12]; let __info = io_buffer.get_info(__v_62, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_63: G = __io_pair.0;
+    let __v_64: G = __io_pair.1;
+    let __v_65: G = G::from_u64(2);
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_65, __v_63, __v_64]; 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 __v_66: G = __r_arr[0];
+    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_66]; 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 __v_67: G = __r_arr[0];
+    let __v_68: G = __r_arr[1];
+    let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_68, __v_67]; 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 __v_69: G = __r_arr[0];
+    let __v_70: G = __r_arr[1];
+    match __v_18.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_26]; 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 __v_71: 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_188] = { let __args: [G; IN_188] = [__v_8, __v_18]; 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_72: G = __r_arr[0];
+                    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_11, __v_18]; 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 __v_73: 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_74: G = G::from_u64(1);
+    let __v_75: G = G::from_u64(1);
+    let __v_76: G = { let __values: [G; 3] = [__v_74, __v_75, __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 } };
+    break '__mc_0 [__v_76];
+  },
+  1u64 => {
+    break '__mc_0 [__v_10];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+  },
+}
+ };
+                        let __v_74: G = __mc_out___mc_0[0];
+                        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_30, __v_66]; 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_75: G = __r_arr[0];
+                        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_20, __v_75]; 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_76: G = __r_arr[0];
+                        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_74, __v_76]; 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_77: G = __r_arr[0];
+                        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_18, __v_77]; 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_78: G = __r_arr[0];
+                        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_7, __v_78]; 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_79: G = __r_arr[0];
+                        let __v_80: G = G::from_u64(0);
+                        let __v_81: G = G::from_u64(109);
+                        let __v_82: G = G::from_u64(0);
+                        let __v_83: G = G::from_u64(117);
+                        let __v_84: G = G::from_u64(0);
+                        let __v_85: G = G::from_u64(108);
+                        let __v_86: G = G::from_u64(0);
+                        let __v_87: G = G::from_u64(116);
+                        let __v_88: G = G::from_u64(0);
+                        let __v_89: G = G::from_u64(105);
+                        let __v_90: G = G::from_u64(0);
+                        let __v_91: G = G::from_u64(45);
+                        let __v_92: G = G::from_u64(0);
+                        let __v_93: G = G::from_u64(115);
+                        let __v_94: G = G::from_u64(0);
+                        let __v_95: G = G::from_u64(116);
+                        let __v_96: G = G::from_u64(0);
+                        let __v_97: G = G::from_u64(97);
+                        let __v_98: G = G::from_u64(0);
+                        let __v_99: G = G::from_u64(114);
+                        let __v_100: G = G::from_u64(0);
+                        let __v_101: G = G::from_u64(107);
+                        let __v_102: G = G::from_u64(0);
+                        let __v_103: G = G::from_u64(47);
+                        let __v_104: G = G::from_u64(0);
+                        let __v_105: G = G::from_u64(118);
+                        let __v_106: G = G::from_u64(0);
+                        let __v_107: G = G::from_u64(48);
+                        let __v_108: G = { let __values: [G; 3] = [__v_106, __v_107, __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_109: G = { let __values: [G; 3] = [__v_104, __v_105, __v_108]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_110: G = { let __values: [G; 3] = [__v_102, __v_103, __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 __v_111: G = { let __values: [G; 3] = [__v_100, __v_101, __v_110]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_112: G = { let __values: [G; 3] = [__v_98, __v_99, __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 __v_113: G = { let __values: [G; 3] = [__v_96, __v_97, __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 __v_114: G = { let __values: [G; 3] = [__v_94, __v_95, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_115: G = { let __values: [G; 3] = [__v_92, __v_93, __v_114]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_116: G = { let __values: [G; 3] = [__v_90, __v_91, __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 __v_117: G = { let __values: [G; 3] = [__v_88, __v_89, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_86, __v_87, __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 __v_119: G = { let __values: [G; 3] = [__v_84, __v_85, __v_118]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_120: G = { let __values: [G; 3] = [__v_82, __v_83, __v_119]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_121: G = { let __values: [G; 3] = [__v_80, __v_81, __v_120]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1);
+                        let __v_123: G = G::from_u64(1);
+                        let __v_124: G = { let __values: [G; 3] = [__v_122, __v_123, __v_123]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_121, __v_124]; 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_125: G = __r_arr[0];
+                        let __v_126: G = __r_arr[1];
+                        let __v_127: G = __r_arr[2];
+                        let __v_128: G = __r_arr[3];
+                        let __v_129: G = __r_arr[4];
+                        let __v_130: G = __r_arr[5];
+                        let __v_131: G = __r_arr[6];
+                        let __v_132: G = __r_arr[7];
+                        let __v_133: G = __r_arr[8];
+                        let __v_134: G = __r_arr[9];
+                        let __v_135: G = __r_arr[10];
+                        let __v_136: G = __r_arr[11];
+                        let __v_137: G = __r_arr[12];
+                        let __v_138: G = __r_arr[13];
+                        let __v_139: G = __r_arr[14];
+                        let __v_140: G = __r_arr[15];
+                        let __v_141: G = __r_arr[16];
+                        let __v_142: G = __r_arr[17];
+                        let __v_143: G = 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_145]; 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_146: G = __r_arr[0];
+                        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_146]; 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_147: G = __r_arr[0];
+                        let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_141, __v_147]; 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 __v_148: G = __r_arr[0];
+                        let __v_149: G = G::from_u64(1);
+                        let __v_150: G = G::from_u64(1);
+                        let __v_151: G = { let __values: [G; 3] = [__v_149, __v_150, __v_150]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_148, __v_151]; 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_152: G = __r_arr[0];
+                        let __v_153: G = __r_arr[1];
+                        let __v_154: G = __r_arr[2];
+                        let __v_155: G = __r_arr[3];
+                        let __v_156: G = __r_arr[4];
+                        let __v_157: G = __r_arr[5];
+                        let __v_158: G = __r_arr[6];
+                        let __v_159: G = __r_arr[7];
+                        let __v_160: G = __r_arr[8];
+                        let __v_161: G = __r_arr[9];
+                        let __v_162: G = __r_arr[10];
+                        let __v_163: G = __r_arr[11];
+                        let __v_164: G = __r_arr[12];
+                        let __v_165: G = __r_arr[13];
+                        let __v_166: G = __r_arr[14];
+                        let __v_167: G = __r_arr[15];
+                        let __v_168: G = __r_arr[16];
+                        let __v_169: G = __r_arr[17];
+                        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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_172]; 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_173: G = __r_arr[0];
+                        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_173]; 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_174: G = __r_arr[0];
+                        let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_168, __v_174]; 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 __v_175: G = __r_arr[0];
+                        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_175, __v_22]; 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 __v_176: G = __r_arr[0];
+                        let __v_177: G = G::from_u64(1);
+                        let __v_178: G = G::from_u64(1);
+                        let __v_179: G = { let __values: [G; 3] = [__v_177, __v_178, __v_178]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_26, __v_179]; 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_180: G = __r_arr[0];
+                        let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_176, __v_180]; 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 __v_181: G = __r_arr[0];
+                        let __v_182: G = G::from_u64(1);
+                        let __v_183: G = G::from_u64(1);
+                        let __v_184: G = { let __values: [G; 3] = [__v_182, __v_183, __v_183]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_181, __v_184]; 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_185: G = __r_arr[0];
+                        let __v_186: G = __r_arr[1];
+                        let __v_187: G = __r_arr[2];
+                        let __v_188: G = __r_arr[3];
+                        let __v_189: G = __r_arr[4];
+                        let __v_190: G = __r_arr[5];
+                        let __v_191: G = __r_arr[6];
+                        let __v_192: G = __r_arr[7];
+                        let __v_193: G = __r_arr[8];
+                        let __v_194: G = __r_arr[9];
+                        let __v_195: G = __r_arr[10];
+                        let __v_196: G = __r_arr[11];
+                        let __v_197: G = __r_arr[12];
+                        let __v_198: G = __r_arr[13];
+                        let __v_199: G = __r_arr[14];
+                        let __v_200: G = __r_arr[15];
+                        let __v_201: G = __r_arr[16];
+                        let __v_202: G = __r_arr[17];
+                        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_201, __v_24]; 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 __v_203: G = __r_arr[0];
+                        let __v_204: G = G::from_u64(1);
+                        let __v_205: G = G::from_u64(1);
+                        let __v_206: G = { let __values: [G; 3] = [__v_204, __v_205, __v_205]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_203, __v_206]; 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_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 __v_217: G = __r_arr[10];
+                        let __v_218: G = __r_arr[11];
+                        let __v_219: G = __r_arr[12];
+                        let __v_220: G = __r_arr[13];
+                        let __v_221: G = __r_arr[14];
+                        let __v_222: G = __r_arr[15];
+                        let __v_223: G = __r_arr[16];
+                        let __v_224: G = __r_arr[17];
+                        let __v_225: G = G::from_u64(256);
+                        let __v_226: G = (__v_225 * __v_126);
+                        let __v_227: G = G::from_u64(65536);
+                        let __v_228: G = (__v_227 * __v_127);
+                        let __v_229: G = G::from_u64(16777216);
+                        let __v_230: G = (__v_229 * __v_128);
+                        let __v_231: G = G::from_u64(4294967296);
+                        let __v_232: G = (__v_231 * __v_129);
+                        let __v_233: G = G::from_u64(1099511627776);
+                        let __v_234: G = (__v_233 * __v_130);
+                        let __v_235: G = G::from_u64(281474976710656);
+                        let __v_236: G = (__v_235 * __v_131);
+                        let __v_237: G = G::from_u64(72057594037927936);
+                        let __v_238: G = (__v_237 * __v_132);
+                        let __v_239: G = (__v_236 + __v_238);
+                        let __v_240: G = (__v_234 + __v_239);
+                        let __v_241: G = (__v_232 + __v_240);
+                        let __v_242: G = (__v_230 + __v_241);
+                        let __v_243: G = (__v_228 + __v_242);
+                        let __v_244: G = (__v_226 + __v_243);
+                        let __v_245: G = (__v_125 + __v_244);
+                        let __v_246: G = G::from_u64(256);
+                        let __v_247: G = (__v_246 * __v_134);
+                        let __v_248: G = G::from_u64(65536);
+                        let __v_249: G = (__v_248 * __v_135);
+                        let __v_250: G = G::from_u64(16777216);
+                        let __v_251: G = (__v_250 * __v_136);
+                        let __v_252: G = G::from_u64(4294967296);
+                        let __v_253: G = (__v_252 * __v_137);
+                        let __v_254: G = G::from_u64(1099511627776);
+                        let __v_255: G = (__v_254 * __v_138);
+                        let __v_256: G = G::from_u64(281474976710656);
+                        let __v_257: G = (__v_256 * __v_139);
+                        let __v_258: G = G::from_u64(72057594037927936);
+                        let __v_259: G = (__v_258 * __v_140);
+                        let __v_260: G = (__v_257 + __v_259);
+                        let __v_261: G = (__v_255 + __v_260);
+                        let __v_262: G = (__v_253 + __v_261);
+                        let __v_263: G = (__v_251 + __v_262);
+                        let __v_264: G = (__v_249 + __v_263);
+                        let __v_265: G = (__v_247 + __v_264);
+                        let __v_266: G = (__v_133 + __v_265);
+                        let __v_267: G = G::from_u64(256);
+                        let __v_268: G = (__v_267 * __v_153);
+                        let __v_269: G = G::from_u64(65536);
+                        let __v_270: G = (__v_269 * __v_154);
+                        let __v_271: G = G::from_u64(16777216);
+                        let __v_272: G = (__v_271 * __v_155);
+                        let __v_273: G = G::from_u64(4294967296);
+                        let __v_274: G = (__v_273 * __v_156);
+                        let __v_275: G = G::from_u64(1099511627776);
+                        let __v_276: G = (__v_275 * __v_157);
+                        let __v_277: G = G::from_u64(281474976710656);
+                        let __v_278: G = (__v_277 * __v_158);
+                        let __v_279: G = G::from_u64(72057594037927936);
+                        let __v_280: G = (__v_279 * __v_159);
+                        let __v_281: G = (__v_278 + __v_280);
+                        let __v_282: G = (__v_276 + __v_281);
+                        let __v_283: G = (__v_274 + __v_282);
+                        let __v_284: G = (__v_272 + __v_283);
+                        let __v_285: G = (__v_270 + __v_284);
+                        let __v_286: G = (__v_268 + __v_285);
+                        let __v_287: G = (__v_152 + __v_286);
+                        let __v_288: G = G::from_u64(256);
+                        let __v_289: G = (__v_288 * __v_161);
+                        let __v_290: G = G::from_u64(65536);
+                        let __v_291: G = (__v_290 * __v_162);
+                        let __v_292: G = G::from_u64(16777216);
+                        let __v_293: G = (__v_292 * __v_163);
+                        let __v_294: G = G::from_u64(4294967296);
+                        let __v_295: G = (__v_294 * __v_164);
+                        let __v_296: G = G::from_u64(1099511627776);
+                        let __v_297: G = (__v_296 * __v_165);
+                        let __v_298: G = G::from_u64(281474976710656);
+                        let __v_299: G = (__v_298 * __v_166);
+                        let __v_300: G = G::from_u64(72057594037927936);
+                        let __v_301: G = (__v_300 * __v_167);
+                        let __v_302: G = (__v_299 + __v_301);
+                        let __v_303: G = (__v_297 + __v_302);
+                        let __v_304: G = (__v_295 + __v_303);
+                        let __v_305: G = (__v_293 + __v_304);
+                        let __v_306: G = (__v_291 + __v_305);
+                        let __v_307: G = (__v_289 + __v_306);
+                        let __v_308: G = (__v_160 + __v_307);
+                        let __v_309: G = G::from_u64(256);
+                        let __v_310: G = (__v_309 * __v_186);
+                        let __v_311: G = G::from_u64(65536);
+                        let __v_312: G = (__v_311 * __v_187);
+                        let __v_313: G = G::from_u64(16777216);
+                        let __v_314: G = (__v_313 * __v_188);
+                        let __v_315: G = G::from_u64(4294967296);
+                        let __v_316: G = (__v_315 * __v_189);
+                        let __v_317: G = G::from_u64(1099511627776);
+                        let __v_318: G = (__v_317 * __v_190);
+                        let __v_319: G = G::from_u64(281474976710656);
+                        let __v_320: G = (__v_319 * __v_191);
+                        let __v_321: G = G::from_u64(72057594037927936);
+                        let __v_322: G = (__v_321 * __v_192);
+                        let __v_323: G = (__v_320 + __v_322);
+                        let __v_324: G = (__v_318 + __v_323);
+                        let __v_325: G = (__v_316 + __v_324);
+                        let __v_326: G = (__v_314 + __v_325);
+                        let __v_327: G = (__v_312 + __v_326);
+                        let __v_328: G = (__v_310 + __v_327);
+                        let __v_329: G = (__v_185 + __v_328);
+                        let __v_330: G = G::from_u64(256);
+                        let __v_331: G = (__v_330 * __v_194);
+                        let __v_332: G = G::from_u64(65536);
+                        let __v_333: G = (__v_332 * __v_195);
+                        let __v_334: G = G::from_u64(16777216);
+                        let __v_335: G = (__v_334 * __v_196);
+                        let __v_336: G = G::from_u64(4294967296);
+                        let __v_337: G = (__v_336 * __v_197);
+                        let __v_338: G = G::from_u64(1099511627776);
+                        let __v_339: G = (__v_338 * __v_198);
+                        let __v_340: G = G::from_u64(281474976710656);
+                        let __v_341: G = (__v_340 * __v_199);
+                        let __v_342: G = G::from_u64(72057594037927936);
+                        let __v_343: G = (__v_342 * __v_200);
+                        let __v_344: G = (__v_341 + __v_343);
+                        let __v_345: G = (__v_339 + __v_344);
+                        let __v_346: G = (__v_337 + __v_345);
+                        let __v_347: G = (__v_335 + __v_346);
+                        let __v_348: G = (__v_333 + __v_347);
+                        let __v_349: G = (__v_331 + __v_348);
+                        let __v_350: G = (__v_193 + __v_349);
+                        let __v_351: G = G::from_u64(256);
+                        let __v_352: G = (__v_351 * __v_208);
+                        let __v_353: G = G::from_u64(65536);
+                        let __v_354: G = (__v_353 * __v_209);
+                        let __v_355: G = G::from_u64(16777216);
+                        let __v_356: G = (__v_355 * __v_210);
+                        let __v_357: G = G::from_u64(4294967296);
+                        let __v_358: G = (__v_357 * __v_211);
+                        let __v_359: G = G::from_u64(1099511627776);
+                        let __v_360: G = (__v_359 * __v_212);
+                        let __v_361: G = G::from_u64(281474976710656);
+                        let __v_362: G = (__v_361 * __v_213);
+                        let __v_363: G = G::from_u64(72057594037927936);
+                        let __v_364: G = (__v_363 * __v_214);
+                        let __v_365: G = (__v_362 + __v_364);
+                        let __v_366: G = (__v_360 + __v_365);
+                        let __v_367: G = (__v_358 + __v_366);
+                        let __v_368: G = (__v_356 + __v_367);
+                        let __v_369: G = (__v_354 + __v_368);
+                        let __v_370: G = (__v_352 + __v_369);
+                        let __v_371: G = (__v_207 + __v_370);
+                        let __v_372: G = G::from_u64(256);
+                        let __v_373: G = (__v_372 * __v_216);
+                        let __v_374: G = G::from_u64(65536);
+                        let __v_375: G = (__v_374 * __v_217);
+                        let __v_376: G = G::from_u64(16777216);
+                        let __v_377: G = (__v_376 * __v_218);
+                        let __v_378: G = G::from_u64(4294967296);
+                        let __v_379: G = (__v_378 * __v_219);
+                        let __v_380: G = G::from_u64(1099511627776);
+                        let __v_381: G = (__v_380 * __v_220);
+                        let __v_382: G = G::from_u64(281474976710656);
+                        let __v_383: G = (__v_382 * __v_221);
+                        let __v_384: G = G::from_u64(72057594037927936);
+                        let __v_385: G = (__v_384 * __v_222);
+                        let __v_386: G = (__v_383 + __v_385);
+                        let __v_387: G = (__v_381 + __v_386);
+                        let __v_388: G = (__v_379 + __v_387);
+                        let __v_389: G = (__v_377 + __v_388);
+                        let __v_390: G = (__v_375 + __v_389);
+                        let __v_391: G = (__v_373 + __v_390);
+                        let __v_392: G = (__v_215 + __v_391);
+                        let __v_393: G = G::from_u64(0);
+                        let __v_394: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_393, __v_394, __v_69, __v_245, __v_266, __v_287, __v_308]; 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_395: G = __r_arr[0];
+                        let __v_396: G = __r_arr[1];
+                        let __v_397: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_72, __v_73, __v_30, __v_26, __v_58, __v_60, __v_55, __v_56, __v_53, __v_397, __v_395, __v_396, __v_245, __v_266, __v_287, __v_308, __v_329, __v_350, __v_371, __v_392]; 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 __v_398: G = __r_arr[0];
+                        let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_72]; 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_399: G = __r_arr[0];
+                        match __v_34.as_canonical_u64() {
+                          _ => {
+                            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_34]; 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 __v_400: G = __r_arr[0];
+                            let __v_401: G = G::from_u64(1);
+                            let __v_402: G = G::from_u64(1);
+                            let __v_403: G = { let __values: [G; 3] = [__v_401, __v_402, __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 __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_55.as_canonical_u64() {
+  0u64 => {
+    break '__mc_1 [__v_403];
+  },
+  1u64 => {
+    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_56, __v_403]; 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_404: G = __r_arr[0];
+    break '__mc_1 [__v_404];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64()));
+  },
+}
+ };
+                            let __v_404: G = __mc_out___mc_1[0];
+                            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_53, __v_404]; 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_405: G = __r_arr[0];
+                            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_60, __v_405]; 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_406: G = __r_arr[0];
+                            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_58, __v_406]; 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_407: G = __r_arr[0];
+                            let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_223, __v_407]; 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 __v_408: G = __r_arr[0];
+                            let __v_409: G = G::from_u64(1);
+                            let __v_410: G = G::from_u64(1);
+                            let __v_411: G = { let __values: [G; 3] = [__v_409, __v_410, __v_410]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_408, __v_411]; 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_412: G = __r_arr[0];
+                            let __v_413: G = __r_arr[1];
+                            let __v_414: G = __r_arr[2];
+                            let __v_415: G = __r_arr[3];
+                            let __v_416: G = __r_arr[4];
+                            let __v_417: G = __r_arr[5];
+                            let __v_418: G = __r_arr[6];
+                            let __v_419: G = __r_arr[7];
+                            let __v_420: G = __r_arr[8];
+                            let __v_421: G = __r_arr[9];
+                            let __v_422: G = __r_arr[10];
+                            let __v_423: G = __r_arr[11];
+                            let __v_424: G = __r_arr[12];
+                            let __v_425: G = __r_arr[13];
+                            let __v_426: G = __r_arr[14];
+                            let __v_427: G = __r_arr[15];
+                            let __v_428: G = __r_arr[16];
+                            let __v_429: G = __r_arr[17];
+                            let __v_430: G = G::from_u64(256);
+                            let __v_431: G = (__v_430 * __v_413);
+                            let __v_432: G = G::from_u64(65536);
+                            let __v_433: G = (__v_432 * __v_414);
+                            let __v_434: G = G::from_u64(16777216);
+                            let __v_435: G = (__v_434 * __v_415);
+                            let __v_436: G = G::from_u64(4294967296);
+                            let __v_437: G = (__v_436 * __v_416);
+                            let __v_438: G = G::from_u64(1099511627776);
+                            let __v_439: G = (__v_438 * __v_417);
+                            let __v_440: G = G::from_u64(281474976710656);
+                            let __v_441: G = (__v_440 * __v_418);
+                            let __v_442: G = G::from_u64(72057594037927936);
+                            let __v_443: G = (__v_442 * __v_419);
+                            let __v_444: G = (__v_441 + __v_443);
+                            let __v_445: G = (__v_439 + __v_444);
+                            let __v_446: G = (__v_437 + __v_445);
+                            let __v_447: G = (__v_435 + __v_446);
+                            let __v_448: G = (__v_433 + __v_447);
+                            let __v_449: G = (__v_431 + __v_448);
+                            let __v_450: G = (__v_412 + __v_449);
+                            let __v_451: G = G::from_u64(256);
+                            let __v_452: G = (__v_451 * __v_421);
+                            let __v_453: G = G::from_u64(65536);
+                            let __v_454: G = (__v_453 * __v_422);
+                            let __v_455: G = G::from_u64(16777216);
+                            let __v_456: G = (__v_455 * __v_423);
+                            let __v_457: G = G::from_u64(4294967296);
+                            let __v_458: G = (__v_457 * __v_424);
+                            let __v_459: G = G::from_u64(1099511627776);
+                            let __v_460: G = (__v_459 * __v_425);
+                            let __v_461: G = G::from_u64(281474976710656);
+                            let __v_462: G = (__v_461 * __v_426);
+                            let __v_463: G = G::from_u64(72057594037927936);
+                            let __v_464: G = (__v_463 * __v_427);
+                            let __v_465: G = (__v_462 + __v_464);
+                            let __v_466: G = (__v_460 + __v_465);
+                            let __v_467: G = (__v_458 + __v_466);
+                            let __v_468: G = (__v_456 + __v_467);
+                            let __v_469: G = (__v_454 + __v_468);
+                            let __v_470: G = (__v_452 + __v_469);
+                            let __v_471: G = (__v_420 + __v_470);
+                            let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_428, __v_34, __v_36, __v_5]; 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_472: G = __r_arr[0];
+                            let __v_473: G = __r_arr[1];
+                            let __v_474: G = G::from_u64(1);
+                            let __v_475: G = G::from_u64(1);
+                            let __v_476: G = { let __values: [G; 3] = [__v_474, __v_475, __v_475]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_42, __v_476]; 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_477: G = __r_arr[0];
+                            let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_473, __v_477]; 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 __v_478: G = __r_arr[0];
+                            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_478, __v_34]; 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_479: G = __r_arr[0];
+                            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_479, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_6]; 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_480: G = __r_arr[0];
+                            let __v_481: G = __r_arr[1];
+                            let __v_482: G = (__v_400 + __v_0);
+                            let __v_483: G = (__v_14 + __v_15);
+                            if (__v_61 != __v_483) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_483.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_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: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_484: G = __loaded[0];
+                            let __v_485: G = __loaded[1];
+                            let __v_486: G = __loaded[2];
+                            let __v_487: G = G::from_u64(1);
+                            let __v_488: G = G::from_u64(1);
+                            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_488) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_485.as_canonical_u64(), rhs: __v_488.as_canonical_u64(), msg: None });
+                            }
+                            if (__v_486 != __v_488) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_486.as_canonical_u64(), rhs: __v_488.as_canonical_u64(), msg: None });
+                            }
+                            let __v_489: G = G::from_bool((__v_71 == G::ZERO));
+                            let __v_490: G = G::from_u64(0);
+                            if (__v_489 != __v_490) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_489.as_canonical_u64(), rhs: __v_490.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_58]; 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 __v_491: G = __r_arr[0];
+                            if (__v_491 != __v_71) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_491.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_60]; 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 __v_492: G = __r_arr[0];
+                            if (__v_492 != __v_71) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_492.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_53]; 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 __v_493: G = __r_arr[0];
+                            if (__v_493 != __v_71) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_493.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_26]; 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_494: G = __r_arr[0];
+                            let __v_495: G = G::from_u64(1);
+                            if (__v_494 != __v_495) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_494.as_canonical_u64(), rhs: __v_495.as_canonical_u64(), msg: None });
+                            }
+                            let __v_496: G = G::from_u64(1);
+                            let __v_497: G = G::from_u64(1);
+                            if (__v_496 != __v_497) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_496.as_canonical_u64(), rhs: __v_497.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_18]; 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 __v_498: G = __r_arr[0];
+                            let __v_499: G = G::from_u64(1);
+                            if (__v_498 != __v_499) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_498.as_canonical_u64(), rhs: __v_499.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_18]; 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 __v_500: G = __r_arr[0];
+                            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_501: G = __r_arr[0];
+                            let __v_502: G = (__v_500 - __v_501);
+                            let __v_503: G = G::from_bool((__v_502 == G::ZERO));
+                            let __v_504: G = G::from_u64(1);
+                            if (__v_503 != __v_504) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_503.as_canonical_u64(), rhs: __v_504.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_72]; 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_505: G = __r_arr[0];
+                            let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_26]; 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 __v_506: G = __r_arr[0];
+                            let __v_507: G = (__v_505 - __v_506);
+                            let __v_508: G = G::from_bool((__v_507 == G::ZERO));
+                            let __v_509: G = G::from_u64(1);
+                            if (__v_508 != __v_509) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_508.as_canonical_u64(), rhs: __v_509.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_36]; 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 __v_510: G = __r_arr[0];
+                            let __v_511: G = (__v_510 - __v_400);
+                            let __v_512: G = G::from_bool((__v_511 == G::ZERO));
+                            let __v_513: G = G::from_u64(1);
+                            if (__v_512 != __v_513) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_513.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_40]; 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 __v_514: G = __r_arr[0];
+                            let __v_515: G = (__v_514 - __v_4);
+                            let __v_516: G = G::from_bool((__v_515 == G::ZERO));
+                            let __v_517: G = G::from_u64(1);
+                            if (__v_516 != __v_517) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_516.as_canonical_u64(), rhs: __v_517.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_42]; 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 __v_518: G = __r_arr[0];
+                            let __v_519: G = G::from_u64(1);
+                            if (__v_518 != __v_519) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_518.as_canonical_u64(), rhs: __v_519.as_canonical_u64(), msg: None });
+                            }
+                            let __v_520: G = G::from_u64(33);
+                            let __v_521: G = { let __a_val = __v_482.as_canonical_u64(); let __b_val = __v_520.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_522: G = G::from_u64(1);
+                            if (__v_521 != __v_522) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_521.as_canonical_u64(), rhs: __v_522.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_480, __v_481, __v_40, __v_450, __v_471, __v_58, __v_60, __v_53, __v_55, __v_56, __v_20, __v_22, __v_24, __v_74, __v_73, __v_30, __v_371, __v_392, __v_399, __v_0, __v_482, __v_472, __v_34, __v_42, __v_400]; 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_523: G = __r_arr[0];
+                            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 __ret: [G; OUT_224] = [__v_69];
+                            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)); };
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_225: usize = 2;
+const IN_225: usize = 2;
+const OUT_225: usize = 3;
+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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(10);
+    let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_0, __v_2]; 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 __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_219] = { let __args: [G; IN_219] = [__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[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 __v_11: G = __r_arr[0];
+    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_11]; 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 __v_12: G = __r_arr[0];
+    let __v_13: G = __r_arr[1];
+    let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_13, __v_12]; 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 __v_14: G = __r_arr[0];
+    let __v_15: G = __r_arr[1];
+    let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_14]; 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 __v_16: G = __r_arr[0];
+    let __v_17: G = G::from_u64(2);
+    let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_16, __v_17]; 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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_26: G = __loaded[0];
+    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_239] = { let __args: [G; IN_239] = [__v_16]; 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 __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_220] = { let __args: [G; IN_220] = [__v_16, __v_33]; 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 __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_220] = { let __args: [G; IN_220] = [__v_16, __v_36]; 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 __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_219] = { let __args: [G; IN_219] = [__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[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 __v_38: G = __r_arr[0];
+    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_38]; 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 __v_39: G = __r_arr[0];
+    let __v_40: G = __r_arr[1];
+    let __v_41: G = __r_arr[2];
+    let __ret: [G; OUT_225] = [__v_39, __v_40, __v_41];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_226: usize = 21;
+const IN_226: usize = 21;
+const OUT_226: usize = 3;
+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 __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 __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__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 __v_21: G = __r_arr[0];
+    let __v_22: G = G::from_u64(1);
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_21, __v_22]; 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 __v_23: G = __r_arr[0];
+    let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_21]; 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 __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_220] = { let __args: [G; IN_220] = [__v_21, __v_26]; 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 __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_31: G = G::from_u64(2);
+        let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_21, __v_31]; 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 __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_222] = { let __args: [G; IN_222] = [__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; 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_225] = { let __args: [G; IN_225] = [__v_21, __v_17]; 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_40: G = __r_arr[0];
+        let __v_41: G = __r_arr[1];
+        let __v_42: G = __r_arr[2];
+        let __ret: [G; OUT_226] = [__v_40, __v_41, __v_42];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        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_221] = { let __args: [G; IN_221] = [__v_21, __v_33]; 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 __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_222] = { let __args: [G; IN_222] = [__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; 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 __v_42: G = G::from_u64(10);
+        let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_21, __v_42]; 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 __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_219] = { let __args: [G; IN_219] = [__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[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 __v_51: G = __r_arr[0];
+        let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_51]; 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 __v_52: G = __r_arr[0];
+        let __v_53: G = __r_arr[1];
+        let __v_54: G = __r_arr[2];
+        let __ret: [G; OUT_226] = [__v_52, __v_53, __v_54];
+        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)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_227: usize = 16;
+const IN_227: usize = 16;
+const OUT_227: usize = 0;
+fn aiur_fn_227(
+  inp: [G; IN_227],
+  record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_191], ExecError> {
+) -> Result<[G; OUT_227], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = 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_2] = { let __args: [G; IN_2] = [__v_20, __v_18, __v_19]; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_57: G = G::from_u64(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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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; 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 __v_72: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; 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 __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_194] = { let __args: [G; IN_194] = [__v_21]; 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_105: G = __r_arr[0];
+    let __v_106: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_106]; 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_107: G = __r_arr[0];
+    let __v_108: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_108]; 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_109: G = __r_arr[0];
+    let __v_110: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_110]; 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_111: G = __r_arr[0];
+    let __v_112: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_112]; 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_113: G = __r_arr[0];
+    let __v_114: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_114]; 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_115: G = __r_arr[0];
+    let __v_116: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_116]; 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_117: G = __r_arr[0];
+    let __v_118: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_118]; 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_119: G = __r_arr[0];
+    let __v_120: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_120]; 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_121: G = __r_arr[0];
+    let __v_122: G = __r_arr[1];
+    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_122]; 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_123: G = __r_arr[0];
+    let __v_124: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_124]; 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_125: G = __r_arr[0];
+    let __v_126: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_126]; 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_127: G = __r_arr[0];
+    let __v_128: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_128]; 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_129: G = __r_arr[0];
+    let __v_130: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_130]; 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_131: G = __r_arr[0];
+    let __v_132: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_132]; 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_133: G = __r_arr[0];
+    let __v_134: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_134]; 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_135: G = __r_arr[0];
+    let __v_136: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_136]; 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_137: G = __r_arr[0];
+    let __v_138: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_138]; 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_139: G = __r_arr[0];
+    let __v_140: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_140]; 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_141: G = __r_arr[0];
+    let __v_142: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_142]; 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_143: G = __r_arr[0];
+    let __v_144: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_144]; 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_145: G = __r_arr[0];
+    let __v_146: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_146]; 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_147: G = __r_arr[0];
+    let __v_148: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_148]; 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_149: G = __r_arr[0];
+    let __v_150: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_150]; 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_151: G = __r_arr[0];
+    let __v_152: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_152]; 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_153: G = __r_arr[0];
+    let __v_154: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_154]; 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_155: G = __r_arr[0];
+    let __v_156: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_156]; 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_157: G = __r_arr[0];
+    let __v_158: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_158]; 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_159: G = __r_arr[0];
+    let __v_160: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_160]; 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_161: G = __r_arr[0];
+    let __v_162: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_162]; 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_163: G = __r_arr[0];
+    let __v_164: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_164]; 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_165: G = __r_arr[0];
+    let __v_166: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_166]; 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_167: G = __r_arr[0];
+    let __v_168: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_168]; 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_169: G = __r_arr[0];
+    let __v_170: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_170]; 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_171: G = __r_arr[0];
+    let __v_172: G = __r_arr[1];
+    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_105]; 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_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_196] = { let __args: [G; IN_196] = [__v_123]; 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_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_12] = { let __args: [G; IN_12] = [__v_107, __v_109, __v_111, __v_113, __v_115, __v_117, __v_119, __v_121]; 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 __v_189: G = __r_arr[0];
+    let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_125, __v_127, __v_129, __v_131, __v_133, __v_135, __v_137, __v_139]; 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 __v_190: G = __r_arr[0];
+    let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_141, __v_143, __v_145, __v_147, __v_149, __v_151, __v_153, __v_155]; 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 __v_191: G = __r_arr[0];
+    let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_157, __v_159, __v_161, __v_163, __v_165, __v_167, __v_169, __v_171]; 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 __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_2] = { let __args: [G; IN_2] = [__v_197, __v_195, __v_196]; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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; 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 __v_249: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_249]; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_351]; 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 __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; 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 __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; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_94(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } } else { aiur_fn_94(__args, record, io_buffer, __cu)? } };
+    let __v_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; 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_368, __v_436]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+    let __v_437: G = __r_arr[0];
+    let __v_438: G = G::from_u64(0);
+    let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__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; 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 __v_439: G = __r_arr[0];
+    let __v_440: G = G::from_u64(1);
+    let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__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; 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 __v_441: G = __r_arr[0];
+    let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__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; 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 __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_226] = { let __args: [G; IN_226] = [__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; 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 __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_2] = { let __args: [G; IN_2] = [__v_452, __v_450, __v_451]; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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; 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 __v_504: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_504]; 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 __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_218] = { let __args: [G; IN_218] = [__v_453]; 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 __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_207] = { let __args: [G; IN_207] = [__v_442]; 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 __v_540: G = __r_arr[0];
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_445]; 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 __v_541: G = __r_arr[0];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_443, __v_444]; 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 __v_542: G = __r_arr[0];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_446, __v_447]; 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 __v_543: G = __r_arr[0];
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_537]; 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 __v_544: G = __r_arr[0];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_538, __v_539]; 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 __v_545: G = __r_arr[0];
+    let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_540, __v_541, __v_544]; 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_213] = { let __args: [G; IN_213] = [__v_542, __v_543, __v_544, __v_545]; 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 __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()) });
+    }
+    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()) });
+    }
+    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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } 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_227] = [];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_228: usize = 16;
+const IN_228: usize = 16;
+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 __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_2] = { let __args: [G; IN_2] = [__v_20, __v_18, __v_19]; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_57: G = G::from_u64(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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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; 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 __v_72: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; 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 __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_194] = { let __args: [G; IN_194] = [__v_21]; 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_105: G = __r_arr[0];
+    let __v_106: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_106]; 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_107: G = __r_arr[0];
+    let __v_108: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_108]; 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_109: G = __r_arr[0];
+    let __v_110: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_110]; 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_111: G = __r_arr[0];
+    let __v_112: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_112]; 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_113: G = __r_arr[0];
+    let __v_114: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_114]; 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_115: G = __r_arr[0];
+    let __v_116: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_116]; 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_117: G = __r_arr[0];
+    let __v_118: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_118]; 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_119: G = __r_arr[0];
+    let __v_120: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_120]; 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_121: G = __r_arr[0];
+    let __v_122: G = __r_arr[1];
+    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_122]; 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_123: G = __r_arr[0];
+    let __v_124: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_124]; 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_125: G = __r_arr[0];
+    let __v_126: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_126]; 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_127: G = __r_arr[0];
+    let __v_128: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_128]; 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_129: G = __r_arr[0];
+    let __v_130: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_130]; 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_131: G = __r_arr[0];
+    let __v_132: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_132]; 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_133: G = __r_arr[0];
+    let __v_134: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_134]; 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_135: G = __r_arr[0];
+    let __v_136: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_136]; 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_137: G = __r_arr[0];
+    let __v_138: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_138]; 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_139: G = __r_arr[0];
+    let __v_140: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_140]; 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_141: G = __r_arr[0];
+    let __v_142: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_142]; 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_143: G = __r_arr[0];
+    let __v_144: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_144]; 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_145: G = __r_arr[0];
+    let __v_146: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_146]; 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_147: G = __r_arr[0];
+    let __v_148: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_148]; 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_149: G = __r_arr[0];
+    let __v_150: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_150]; 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_151: G = __r_arr[0];
+    let __v_152: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_152]; 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_153: G = __r_arr[0];
+    let __v_154: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_154]; 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_155: G = __r_arr[0];
+    let __v_156: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_156]; 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_157: G = __r_arr[0];
+    let __v_158: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_158]; 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_159: G = __r_arr[0];
+    let __v_160: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_160]; 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_161: G = __r_arr[0];
+    let __v_162: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_162]; 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_163: G = __r_arr[0];
+    let __v_164: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_164]; 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_165: G = __r_arr[0];
+    let __v_166: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_166]; 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_167: G = __r_arr[0];
+    let __v_168: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_168]; 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_169: G = __r_arr[0];
+    let __v_170: G = __r_arr[1];
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_170]; 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_171: G = __r_arr[0];
+    let __v_172: G = __r_arr[1];
+    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_105]; 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_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_196] = { let __args: [G; IN_196] = [__v_123]; 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_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_12] = { let __args: [G; IN_12] = [__v_107, __v_109, __v_111, __v_113, __v_115, __v_117, __v_119, __v_121]; 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 __v_189: G = __r_arr[0];
+    let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_125, __v_127, __v_129, __v_131, __v_133, __v_135, __v_137, __v_139]; 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 __v_190: G = __r_arr[0];
+    let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_141, __v_143, __v_145, __v_147, __v_149, __v_151, __v_153, __v_155]; 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 __v_191: G = __r_arr[0];
+    let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_157, __v_159, __v_161, __v_163, __v_165, __v_167, __v_169, __v_171]; 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 __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_2] = { let __args: [G; IN_2] = [__v_197, __v_195, __v_196]; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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; 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 __v_249: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_249]; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_351]; 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 __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; 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 __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; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_94(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } } else { aiur_fn_94(__args, record, io_buffer, __cu)? } };
+    let __v_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; 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_368, __v_436]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+    let __v_437: G = __r_arr[0];
+    let __v_438: G = G::from_u64(0);
+    let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__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; 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 __v_439: G = __r_arr[0];
+    let __v_440: G = G::from_u64(1);
+    let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__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; 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 __v_441: G = __r_arr[0];
+    let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__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; 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 __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_226] = { let __args: [G; IN_226] = [__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; 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 __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_2] = { let __args: [G; IN_2] = [__v_452, __v_450, __v_451]; 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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; 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 __v_504: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_504]; 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 __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_218] = { let __args: [G; IN_218] = [__v_453]; 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 __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_197] = { let __args: [G; IN_197] = [__v_442, __v_445]; 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_540: G = __r_arr[0];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_443, __v_444]; 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 __v_541: G = __r_arr[0];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_446, __v_447]; 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 __v_542: G = __r_arr[0];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_538, __v_539]; 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 __v_543: G = __r_arr[0];
+    let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_541, __v_542, __v_537, __v_543]; 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 __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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } 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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } 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_1] = { let __args: [G; IN_1] = [__v_537, __v_540]; 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 __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_228] = [];
+    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)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_229: usize = 16;
+const IN_229: usize = 16;
+const OUT_229: usize = 0;
+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 __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18218,49 +24362,49 @@ 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_29] = { let __args: [G; IN_29] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_20: G = __r_arr[0];
     let __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_33] = { let __args: [G; IN_33] = [__v_21, __v_20]; 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_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_38] = { let __args: [G; IN_38] = [__v_23]; 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 __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_38] = { let __args: [G; IN_38] = [__v_25]; 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 __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_38] = { let __args: [G; IN_38] = [__v_27]; 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 __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_36] = { let __args: [G; IN_36] = [__v_29]; 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_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_29] = { let __args: [G; IN_29] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_33] = { let __args: [G; IN_33] = [__v_33, __v_32]; 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_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_29] = { let __args: [G; IN_29] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_48] = { let __args: [G; IN_48] = [__v_37, __v_36]; 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 __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_34] = { let __args: [G; IN_34] = [__v_39]; 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_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_29] = { let __args: [G; IN_29] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
     let __v_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_58] = { let __args: [G; IN_58] = [__v_43, __v_42]; 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_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_36] = { let __args: [G; IN_36] = [__v_45]; 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_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_28] = { let __args: [G; IN_28] = [__v_47]; let __cu = true; 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 { let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
     let __v_48: G = __r_arr[0];
     let __v_49: G = __r_arr[1];
     let __v_50: G = __r_arr[2];
@@ -18270,17 +24414,17 @@ fn aiur_fn_191(
     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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_56]; 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 __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 __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_58]; 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 __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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_61]; 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 __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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_63]; 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 __v_64: G = __r_arr[0];
     let __v_65: G = __r_arr[1];
     let __v_66: G = G::from_u64(1);
@@ -18289,7 +24433,7 @@ fn aiur_fn_191(
     let __v_68: G = __io_pair.0;
     let __v_69: G = __io_pair.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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_70, __v_68, __v_69]; 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 __v_71: G = __r_arr[0];
     let __v_72: G = G::from_u64(103);
     let __v_73: G = G::from_u64(230);
@@ -18341,9 +24485,9 @@ fn aiur_fn_191(
     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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_71, __v_106, __v_107, __v_108, __v_117, __v_118, __v_121]; 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 __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 __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_122]; 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 __v_123: G = __r_arr[0];
     let __v_124: G = __r_arr[1];
     let __v_125: G = __r_arr[2];
@@ -18376,7 +24520,7 @@ fn aiur_fn_191(
     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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_71]; 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 __v_155: G = __r_arr[0];
     let __v_156: G = __r_arr[1];
     let __v_157: G = __r_arr[2];
@@ -18387,7 +24531,7 @@ fn aiur_fn_191(
     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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_164]; 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 __v_165: G = __r_arr[0];
     let __v_166: G = __r_arr[1];
     let __v_167: G = __r_arr[2];
@@ -18398,7 +24542,7 @@ fn aiur_fn_191(
     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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_174]; 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 __v_175: G = __r_arr[0];
     let __v_176: G = __r_arr[1];
     let __v_177: G = __r_arr[2];
@@ -18409,7 +24553,7 @@ fn aiur_fn_191(
     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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_184]; 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 __v_185: G = __r_arr[0];
     let __v_186: G = __r_arr[1];
     let __v_187: G = __r_arr[2];
@@ -18420,7 +24564,7 @@ fn aiur_fn_191(
     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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_194]; 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 __v_195: G = __r_arr[0];
     let __v_196: G = __r_arr[1];
     let __v_197: G = __r_arr[2];
@@ -18431,7 +24575,7 @@ fn aiur_fn_191(
     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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_204]; 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 __v_205: G = __r_arr[0];
     let __v_206: G = __r_arr[1];
     let __v_207: G = __r_arr[2];
@@ -18442,7 +24586,7 @@ fn aiur_fn_191(
     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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_214]; 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 __v_215: G = __r_arr[0];
     let __v_216: G = __r_arr[1];
     let __v_217: G = __r_arr[2];
@@ -18470,7 +24614,7 @@ fn aiur_fn_191(
     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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_224]; 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 __v_242: G = __r_arr[0];
     let __v_243: G = __r_arr[1];
     let __v_244: G = __r_arr[2];
@@ -18481,174 +24625,233 @@ fn aiur_fn_191(
     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 __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_251, __v_242]; 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 __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 __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_254]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_94(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } } else { aiur_fn_94(__args, record, io_buffer, __cu)? } };
     let __v_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 __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_257, __v_242]; 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_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_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_260: G = G::from_u64(1);
+    let __gb: [u8; 8] = __v_260.as_canonical_u64().to_le_bytes();
+    let __v_261: G = G::from_u8(__gb[0]);
+    let __v_262: G = G::from_u8(__gb[1]);
+    let __v_263: G = G::from_u8(__gb[2]);
+    let __v_264: G = G::from_u8(__gb[3]);
+    let __v_265: G = G::from_u8(__gb[4]);
+    let __v_266: G = G::from_u8(__gb[5]);
+    let __v_267: G = G::from_u8(__gb[6]);
+    let __v_268: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_261; let __vj = __v_262; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); 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_263; let __vj = __v_264; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); 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_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_269: G = G::from_u64(1020);
+    let __v_270: G = (__v_268 - __v_269);
+    let __v_271: G = (__v_267 + __v_270);
+    let __v_272: G = (__v_266 + __v_271);
+    let __v_273: G = (__v_265 + __v_272);
+    let __v_274: G = G::from_bool((__v_273 == G::ZERO));
+    let __v_275: G = (__v_263 + __v_264);
+    let __v_276: G = (__v_262 + __v_275);
+    let __v_277: G = (__v_261 + __v_276);
+    let __v_278: G = G::from_bool((__v_277 == G::ZERO));
+    let __v_279: G = G::from_u64(256);
+    let __v_280: G = (__v_279 * __v_262);
+    let __v_281: G = G::from_u64(65536);
+    let __v_282: G = (__v_281 * __v_263);
+    let __v_283: G = G::from_u64(16777216);
+    let __v_284: G = (__v_283 * __v_264);
+    let __v_285: G = G::from_u64(4294967296);
+    let __v_286: G = (__v_285 * __v_265);
+    let __v_287: G = G::from_u64(1099511627776);
+    let __v_288: G = (__v_287 * __v_266);
+    let __v_289: G = G::from_u64(281474976710656);
+    let __v_290: G = (__v_289 * __v_267);
+    let __v_291: G = G::from_u64(72057594037927936);
+    let __v_292: G = (__v_291 * __v_268);
+    let __v_293: G = (__v_290 + __v_292);
+    let __v_294: G = (__v_288 + __v_293);
+    let __v_295: G = (__v_286 + __v_294);
+    let __v_296: G = (__v_284 + __v_295);
+    let __v_297: G = (__v_282 + __v_296);
+    let __v_298: G = (__v_280 + __v_297);
+    let __v_299: G = (__v_261 + __v_298);
+    if (__v_299 != __v_260) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_299.as_canonical_u64(), rhs: __v_260.as_canonical_u64(), msg: None });
+    }
+    let __v_300: G = G::from_u64(1);
     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_302: G = (__v_301 - __v_278);
+    let __v_303: G = (__v_274 * __v_302);
+    let __v_304: G = (__v_300 - __v_303);
+    let __v_305: G = G::from_u64(1);
+    if (__v_304 != __v_305) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_304.as_canonical_u64(), rhs: __v_305.as_canonical_u64(), msg: None });
+    }
     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_310: G = G::from_u64(0);
-    let __v_311: G = G::from_u64(0);
+    let __v_308: G = { let __values: [G; 10] = [__v_307, __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 __v_309: G = { let __values: [G; 10] = [__v_306, __v_261, __v_262, __v_263, __v_264, __v_265, __v_266, __v_267, __v_268, __v_308]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_241, __v_309]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+    let __v_310: G = __r_arr[0];
+    let __v_311: G = G::from_u64(2);
     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_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 __io_pair: (G, G) = { let __key: [G; 1] = [__v_312]; let __info = io_buffer.get_info(__v_311, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_313: G = __io_pair.0;
+    let __v_314: G = __io_pair.1;
+    let __v_315: G = G::from_u64(2);
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_315, __v_313, __v_314]; 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 __v_316: G = __r_arr[0];
+    let __v_317: G = G::from_u64(103);
+    let __v_318: G = G::from_u64(230);
+    let __v_319: G = G::from_u64(9);
+    let __v_320: G = G::from_u64(106);
+    let __v_321: G = G::from_u64(133);
+    let __v_322: G = G::from_u64(174);
+    let __v_323: G = G::from_u64(103);
+    let __v_324: G = G::from_u64(187);
+    let __v_325: G = G::from_u64(114);
+    let __v_326: G = G::from_u64(243);
+    let __v_327: G = G::from_u64(110);
+    let __v_328: G = G::from_u64(60);
+    let __v_329: G = G::from_u64(58);
+    let __v_330: G = G::from_u64(245);
+    let __v_331: G = G::from_u64(79);
+    let __v_332: G = G::from_u64(165);
+    let __v_333: G = G::from_u64(127);
+    let __v_334: G = G::from_u64(82);
+    let __v_335: G = G::from_u64(14);
+    let __v_336: G = G::from_u64(81);
+    let __v_337: G = G::from_u64(140);
+    let __v_338: G = G::from_u64(104);
+    let __v_339: G = G::from_u64(5);
+    let __v_340: G = G::from_u64(155);
+    let __v_341: G = G::from_u64(171);
+    let __v_342: G = G::from_u64(217);
+    let __v_343: G = G::from_u64(131);
+    let __v_344: G = G::from_u64(31);
+    let __v_345: G = G::from_u64(25);
+    let __v_346: G = G::from_u64(205);
+    let __v_347: G = G::from_u64(224);
+    let __v_348: G = G::from_u64(91);
+    let __v_349: G = G::from_u64(1);
+    let __v_350: G = G::from_u64(1);
+    let __v_351: G = { let __values: [G; 3] = [__v_349, __v_350, __v_350]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    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(0);
+    let __v_360: G = G::from_u64(0);
+    let __v_361: G = G::from_u64(0);
+    let __v_362: G = { let __values: [G; 8] = [__v_354, __v_355, __v_356, __v_357, __v_358, __v_359, __v_360, __v_361]; 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_363: G = { let __values: [G; 32] = [__v_317, __v_318, __v_319, __v_320, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_364: G = G::from_u64(1);
+    let __v_365: G = G::from_u64(1);
+    let __v_366: G = { let __values: [G; 34] = [__v_364, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365, __v_365]; 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_68] = { let __args: [G; IN_68] = [__v_316, __v_351, __v_352, __v_353, __v_362, __v_363, __v_366]; 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 __v_367: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_367]; 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 __v_368: G = __r_arr[0];
+    let __v_369: G = __r_arr[1];
+    let __v_370: G = __r_arr[2];
+    let __v_371: G = __r_arr[3];
+    let __v_372: G = __r_arr[4];
+    let __v_373: G = __r_arr[5];
+    let __v_374: G = __r_arr[6];
+    let __v_375: G = __r_arr[7];
+    let __v_376: G = __r_arr[8];
+    let __v_377: G = __r_arr[9];
+    let __v_378: G = __r_arr[10];
+    let __v_379: G = __r_arr[11];
+    let __v_380: G = __r_arr[12];
+    let __v_381: G = __r_arr[13];
+    let __v_382: G = __r_arr[14];
+    let __v_383: G = __r_arr[15];
+    let __v_384: G = __r_arr[16];
+    let __v_385: G = __r_arr[17];
+    let __v_386: G = __r_arr[18];
+    let __v_387: G = __r_arr[19];
+    let __v_388: G = __r_arr[20];
+    let __v_389: G = __r_arr[21];
+    let __v_390: G = __r_arr[22];
+    let __v_391: G = __r_arr[23];
+    let __v_392: G = __r_arr[24];
+    let __v_393: G = __r_arr[25];
+    let __v_394: G = __r_arr[26];
+    let __v_395: G = __r_arr[27];
+    let __v_396: G = __r_arr[28];
+    let __v_397: G = __r_arr[29];
+    let __v_398: G = __r_arr[30];
+    let __v_399: G = __r_arr[31];
+    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_316]; 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 __v_400: G = __r_arr[0];
+    let __v_401: G = __r_arr[1];
+    let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_401, __v_400]; 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 __v_402: G = __r_arr[0];
+    let __v_403: 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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_30]; 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 __v_404: G = __r_arr[0];
+    let __v_405: G = G::from_bool((__v_404 == G::ZERO));
+    let __v_406: G = G::from_u64(0);
+    if (__v_405 != __v_406) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_405.as_canonical_u64(), rhs: __v_406.as_canonical_u64(), msg: None });
     }
-    let __v_364: G = G::from_u64(1);
-    break '__mc_0 [__v_364];
+    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_62]; 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 __v_407: G = __r_arr[0];
+    if (__v_407 != __v_404) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_407.as_canonical_u64(), rhs: __v_404.as_canonical_u64(), msg: None });
+    }
+    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_64]; 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 __v_408: G = __r_arr[0];
+    if (__v_408 != __v_404) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_408.as_canonical_u64(), rhs: __v_404.as_canonical_u64(), msg: None });
+    }
+    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_57]; 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 __v_409: G = __r_arr[0];
+    if (__v_409 != __v_404) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_409.as_canonical_u64(), rhs: __v_404.as_canonical_u64(), msg: None });
+    }
+    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_30]; 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_410: G = __r_arr[0];
+    let __v_411: G = G::from_u64(1);
+    if (__v_410 != __v_411) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_410.as_canonical_u64(), rhs: __v_411.as_canonical_u64(), msg: None });
+    }
+    let __v_412: G = G::from_u64(1);
+    break '__mc_0 [__v_412];
   },
 }
  };
-    let __v_356: G = __mc_out___mc_0[0];
+    let __v_404: G = __mc_out___mc_0[0];
     let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_155.as_canonical_u64() {
   _ => {
     match __v_155.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_188] = { let __args: [G; IN_188] = [__v_252, __v_22]; 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_405: G = __r_arr[0];
+            let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_258, __v_22]; 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 __v_406: 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() {
   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_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 } };
+    break '__mc_2 [__v_409];
   },
   1u64 => {
     break '__mc_2 [__v_256];
@@ -18658,521 +24861,521 @@ fn aiur_fn_191(
   },
 }
  };
-                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_407: G = __mc_out___mc_2[0];
+                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_34, __v_316]; 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_408: G = __r_arr[0];
+                let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_24, __v_408]; 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_409: G = __r_arr[0];
+                let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_407, __v_409]; 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_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 __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_22, __v_410]; 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_411: G = __r_arr[0];
+                let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_310, __v_411]; 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_412: G = __r_arr[0];
+                let __v_413: G = G::from_u64(0);
+                let __v_414: G = G::from_u64(109);
+                let __v_415: G = G::from_u64(0);
+                let __v_416: G = G::from_u64(117);
+                let __v_417: G = G::from_u64(0);
+                let __v_418: G = G::from_u64(108);
+                let __v_419: G = G::from_u64(0);
+                let __v_420: G = G::from_u64(116);
+                let __v_421: G = G::from_u64(0);
+                let __v_422: G = G::from_u64(105);
+                let __v_423: G = G::from_u64(0);
+                let __v_424: G = G::from_u64(45);
+                let __v_425: G = G::from_u64(0);
+                let __v_426: G = G::from_u64(115);
+                let __v_427: G = G::from_u64(0);
+                let __v_428: G = G::from_u64(116);
+                let __v_429: G = G::from_u64(0);
+                let __v_430: G = G::from_u64(97);
+                let __v_431: G = G::from_u64(0);
+                let __v_432: G = G::from_u64(114);
+                let __v_433: G = G::from_u64(0);
+                let __v_434: G = G::from_u64(107);
+                let __v_435: G = G::from_u64(0);
+                let __v_436: G = G::from_u64(47);
+                let __v_437: G = G::from_u64(0);
+                let __v_438: G = G::from_u64(118);
+                let __v_439: G = G::from_u64(0);
+                let __v_440: G = G::from_u64(48);
+                let __v_441: G = { let __values: [G; 3] = [__v_439, __v_440, __v_412]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_442: G = { let __values: [G; 3] = [__v_437, __v_438, __v_441]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_443: G = { let __values: [G; 3] = [__v_435, __v_436, __v_442]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_444: G = { let __values: [G; 3] = [__v_433, __v_434, __v_443]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_445: G = { let __values: [G; 3] = [__v_431, __v_432, __v_444]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_446: G = { let __values: [G; 3] = [__v_429, __v_430, __v_445]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_447: G = { let __values: [G; 3] = [__v_427, __v_428, __v_446]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_448: G = { let __values: [G; 3] = [__v_425, __v_426, __v_447]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_449: G = { let __values: [G; 3] = [__v_423, __v_424, __v_448]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_450: G = { let __values: [G; 3] = [__v_421, __v_422, __v_449]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_451: G = { let __values: [G; 3] = [__v_419, __v_420, __v_450]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_452: G = { let __values: [G; 3] = [__v_417, __v_418, __v_451]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_453: G = { let __values: [G; 3] = [__v_415, __v_416, __v_452]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_454: G = { let __values: [G; 3] = [__v_413, __v_414, __v_453]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_454, __v_457]; 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_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_459: G = __r_arr[1];
+                let __v_460: G = __r_arr[2];
+                let __v_461: G = __r_arr[3];
+                let __v_462: G = __r_arr[4];
+                let __v_463: G = __r_arr[5];
+                let __v_464: G = __r_arr[6];
+                let __v_465: G = __r_arr[7];
+                let __v_466: G = __r_arr[8];
+                let __v_467: G = __r_arr[9];
+                let __v_468: G = __r_arr[10];
+                let __v_469: G = __r_arr[11];
+                let __v_470: G = __r_arr[12];
+                let __v_471: G = __r_arr[13];
+                let __v_472: G = __r_arr[14];
+                let __v_473: G = __r_arr[15];
+                let __v_474: G = __r_arr[16];
+                let __v_475: G = __r_arr[17];
+                let __v_476: G = G::from_u64(1);
+                let __v_477: G = G::from_u64(1);
+                let __v_478: G = { let __values: [G; 3] = [__v_476, __v_477, __v_477]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_466, __v_467, __v_468, __v_469, __v_470, __v_471, __v_472, __v_473, __v_478]; 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_479: G = __r_arr[0];
+                let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_458, __v_459, __v_460, __v_461, __v_462, __v_463, __v_464, __v_465, __v_479]; 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_480: G = __r_arr[0];
+                let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_474, __v_480]; 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 __v_481: G = __r_arr[0];
+                let __v_482: G = G::from_u64(1);
+                let __v_483: G = G::from_u64(1);
+                let __v_484: G = { let __values: [G; 3] = [__v_482, __v_483, __v_483]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_481, __v_484]; 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_485: G = __r_arr[0];
+                let __v_486: G = __r_arr[1];
+                let __v_487: G = __r_arr[2];
+                let __v_488: G = __r_arr[3];
+                let __v_489: G = __r_arr[4];
+                let __v_490: G = __r_arr[5];
+                let __v_491: G = __r_arr[6];
+                let __v_492: G = __r_arr[7];
+                let __v_493: G = __r_arr[8];
+                let __v_494: G = __r_arr[9];
+                let __v_495: G = __r_arr[10];
+                let __v_496: G = __r_arr[11];
+                let __v_497: G = __r_arr[12];
+                let __v_498: G = __r_arr[13];
+                let __v_499: G = __r_arr[14];
+                let __v_500: G = __r_arr[15];
+                let __v_501: G = __r_arr[16];
+                let __v_502: G = __r_arr[17];
+                let __v_503: G = G::from_u64(1);
+                let __v_504: G = G::from_u64(1);
+                let __v_505: G = { let __values: [G; 3] = [__v_503, __v_504, __v_504]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_493, __v_494, __v_495, __v_496, __v_497, __v_498, __v_499, __v_500, __v_505]; 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_506: G = __r_arr[0];
+                let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_485, __v_486, __v_487, __v_488, __v_489, __v_490, __v_491, __v_492, __v_506]; 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_507: G = __r_arr[0];
+                let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_501, __v_507]; 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 __v_508: G = __r_arr[0];
+                let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_508, __v_26]; 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 __v_509: G = __r_arr[0];
+                let __v_510: G = G::from_u64(1);
+                let __v_511: G = G::from_u64(1);
+                let __v_512: G = { let __values: [G; 3] = [__v_510, __v_511, __v_511]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_30, __v_512]; 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_513: G = __r_arr[0];
+                let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_509, __v_513]; 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 __v_514: G = __r_arr[0];
+                let __v_515: G = G::from_u64(1);
+                let __v_516: G = G::from_u64(1);
+                let __v_517: G = { let __values: [G; 3] = [__v_515, __v_516, __v_516]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_514, __v_517]; 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_518: G = __r_arr[0];
+                let __v_519: G = __r_arr[1];
+                let __v_520: G = __r_arr[2];
+                let __v_521: G = __r_arr[3];
+                let __v_522: G = __r_arr[4];
+                let __v_523: G = __r_arr[5];
+                let __v_524: G = __r_arr[6];
+                let __v_525: G = __r_arr[7];
+                let __v_526: G = __r_arr[8];
+                let __v_527: G = __r_arr[9];
+                let __v_528: G = __r_arr[10];
+                let __v_529: G = __r_arr[11];
+                let __v_530: G = __r_arr[12];
+                let __v_531: G = __r_arr[13];
+                let __v_532: G = __r_arr[14];
+                let __v_533: G = __r_arr[15];
+                let __v_534: G = __r_arr[16];
+                let __v_535: G = __r_arr[17];
+                let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_534, __v_28]; 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 __v_536: G = __r_arr[0];
+                let __v_537: G = G::from_u64(1);
+                let __v_538: G = G::from_u64(1);
+                let __v_539: G = { let __values: [G; 3] = [__v_537, __v_538, __v_538]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_536, __v_539]; 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_540: G = __r_arr[0];
+                let __v_541: G = __r_arr[1];
+                let __v_542: G = __r_arr[2];
+                let __v_543: G = __r_arr[3];
+                let __v_544: G = __r_arr[4];
+                let __v_545: G = __r_arr[5];
+                let __v_546: G = __r_arr[6];
+                let __v_547: G = __r_arr[7];
+                let __v_548: G = __r_arr[8];
+                let __v_549: G = __r_arr[9];
+                let __v_550: G = __r_arr[10];
+                let __v_551: G = __r_arr[11];
+                let __v_552: G = __r_arr[12];
+                let __v_553: G = __r_arr[13];
+                let __v_554: G = __r_arr[14];
+                let __v_555: G = __r_arr[15];
+                let __v_556: G = __r_arr[16];
+                let __v_557: G = __r_arr[17];
+                let __v_558: G = G::from_u64(256);
+                let __v_559: G = (__v_558 * __v_459);
+                let __v_560: G = G::from_u64(65536);
+                let __v_561: G = (__v_560 * __v_460);
+                let __v_562: G = G::from_u64(16777216);
+                let __v_563: G = (__v_562 * __v_461);
+                let __v_564: G = G::from_u64(4294967296);
+                let __v_565: G = (__v_564 * __v_462);
+                let __v_566: G = G::from_u64(1099511627776);
+                let __v_567: G = (__v_566 * __v_463);
+                let __v_568: G = G::from_u64(281474976710656);
+                let __v_569: G = (__v_568 * __v_464);
+                let __v_570: G = G::from_u64(72057594037927936);
+                let __v_571: G = (__v_570 * __v_465);
+                let __v_572: G = (__v_569 + __v_571);
+                let __v_573: G = (__v_567 + __v_572);
+                let __v_574: G = (__v_565 + __v_573);
+                let __v_575: G = (__v_563 + __v_574);
+                let __v_576: G = (__v_561 + __v_575);
+                let __v_577: G = (__v_559 + __v_576);
+                let __v_578: G = (__v_458 + __v_577);
+                let __v_579: G = G::from_u64(256);
+                let __v_580: G = (__v_579 * __v_467);
+                let __v_581: G = G::from_u64(65536);
+                let __v_582: G = (__v_581 * __v_468);
+                let __v_583: G = G::from_u64(16777216);
+                let __v_584: G = (__v_583 * __v_469);
+                let __v_585: G = G::from_u64(4294967296);
+                let __v_586: G = (__v_585 * __v_470);
+                let __v_587: G = G::from_u64(1099511627776);
+                let __v_588: G = (__v_587 * __v_471);
+                let __v_589: G = G::from_u64(281474976710656);
+                let __v_590: G = (__v_589 * __v_472);
+                let __v_591: G = G::from_u64(72057594037927936);
+                let __v_592: G = (__v_591 * __v_473);
+                let __v_593: G = (__v_590 + __v_592);
+                let __v_594: G = (__v_588 + __v_593);
+                let __v_595: G = (__v_586 + __v_594);
+                let __v_596: G = (__v_584 + __v_595);
+                let __v_597: G = (__v_582 + __v_596);
+                let __v_598: G = (__v_580 + __v_597);
+                let __v_599: G = (__v_466 + __v_598);
+                let __v_600: G = G::from_u64(256);
+                let __v_601: G = (__v_600 * __v_486);
+                let __v_602: G = G::from_u64(65536);
+                let __v_603: G = (__v_602 * __v_487);
+                let __v_604: G = G::from_u64(16777216);
+                let __v_605: G = (__v_604 * __v_488);
+                let __v_606: G = G::from_u64(4294967296);
+                let __v_607: G = (__v_606 * __v_489);
+                let __v_608: G = G::from_u64(1099511627776);
+                let __v_609: G = (__v_608 * __v_490);
+                let __v_610: G = G::from_u64(281474976710656);
+                let __v_611: G = (__v_610 * __v_491);
+                let __v_612: G = G::from_u64(72057594037927936);
+                let __v_613: G = (__v_612 * __v_492);
+                let __v_614: G = (__v_611 + __v_613);
+                let __v_615: G = (__v_609 + __v_614);
+                let __v_616: G = (__v_607 + __v_615);
+                let __v_617: G = (__v_605 + __v_616);
+                let __v_618: G = (__v_603 + __v_617);
+                let __v_619: G = (__v_601 + __v_618);
+                let __v_620: G = (__v_485 + __v_619);
+                let __v_621: G = G::from_u64(256);
+                let __v_622: G = (__v_621 * __v_494);
+                let __v_623: G = G::from_u64(65536);
+                let __v_624: G = (__v_623 * __v_495);
+                let __v_625: G = G::from_u64(16777216);
+                let __v_626: G = (__v_625 * __v_496);
+                let __v_627: G = G::from_u64(4294967296);
+                let __v_628: G = (__v_627 * __v_497);
+                let __v_629: G = G::from_u64(1099511627776);
+                let __v_630: G = (__v_629 * __v_498);
+                let __v_631: G = G::from_u64(281474976710656);
+                let __v_632: G = (__v_631 * __v_499);
+                let __v_633: G = G::from_u64(72057594037927936);
+                let __v_634: G = (__v_633 * __v_500);
+                let __v_635: G = (__v_632 + __v_634);
+                let __v_636: G = (__v_630 + __v_635);
+                let __v_637: G = (__v_628 + __v_636);
+                let __v_638: G = (__v_626 + __v_637);
+                let __v_639: G = (__v_624 + __v_638);
+                let __v_640: G = (__v_622 + __v_639);
+                let __v_641: G = (__v_493 + __v_640);
+                let __v_642: G = G::from_u64(256);
+                let __v_643: G = (__v_642 * __v_519);
+                let __v_644: G = G::from_u64(65536);
+                let __v_645: G = (__v_644 * __v_520);
+                let __v_646: G = G::from_u64(16777216);
+                let __v_647: G = (__v_646 * __v_521);
+                let __v_648: G = G::from_u64(4294967296);
+                let __v_649: G = (__v_648 * __v_522);
+                let __v_650: G = G::from_u64(1099511627776);
+                let __v_651: G = (__v_650 * __v_523);
+                let __v_652: G = G::from_u64(281474976710656);
+                let __v_653: G = (__v_652 * __v_524);
+                let __v_654: G = G::from_u64(72057594037927936);
+                let __v_655: G = (__v_654 * __v_525);
+                let __v_656: G = (__v_653 + __v_655);
+                let __v_657: G = (__v_651 + __v_656);
+                let __v_658: G = (__v_649 + __v_657);
+                let __v_659: G = (__v_647 + __v_658);
+                let __v_660: G = (__v_645 + __v_659);
+                let __v_661: G = (__v_643 + __v_660);
+                let __v_662: G = (__v_518 + __v_661);
+                let __v_663: G = G::from_u64(256);
+                let __v_664: G = (__v_663 * __v_527);
+                let __v_665: G = G::from_u64(65536);
+                let __v_666: G = (__v_665 * __v_528);
+                let __v_667: G = G::from_u64(16777216);
+                let __v_668: G = (__v_667 * __v_529);
+                let __v_669: G = G::from_u64(4294967296);
+                let __v_670: G = (__v_669 * __v_530);
+                let __v_671: G = G::from_u64(1099511627776);
+                let __v_672: G = (__v_671 * __v_531);
+                let __v_673: G = G::from_u64(281474976710656);
+                let __v_674: G = (__v_673 * __v_532);
+                let __v_675: G = G::from_u64(72057594037927936);
+                let __v_676: G = (__v_675 * __v_533);
+                let __v_677: G = (__v_674 + __v_676);
+                let __v_678: G = (__v_672 + __v_677);
+                let __v_679: G = (__v_670 + __v_678);
+                let __v_680: G = (__v_668 + __v_679);
+                let __v_681: G = (__v_666 + __v_680);
+                let __v_682: G = (__v_664 + __v_681);
+                let __v_683: G = (__v_526 + __v_682);
+                let __v_684: G = G::from_u64(256);
+                let __v_685: G = (__v_684 * __v_541);
+                let __v_686: G = G::from_u64(65536);
+                let __v_687: G = (__v_686 * __v_542);
+                let __v_688: G = G::from_u64(16777216);
+                let __v_689: G = (__v_688 * __v_543);
+                let __v_690: G = G::from_u64(4294967296);
+                let __v_691: G = (__v_690 * __v_544);
+                let __v_692: G = G::from_u64(1099511627776);
+                let __v_693: G = (__v_692 * __v_545);
+                let __v_694: G = G::from_u64(281474976710656);
+                let __v_695: G = (__v_694 * __v_546);
+                let __v_696: G = G::from_u64(72057594037927936);
+                let __v_697: G = (__v_696 * __v_547);
+                let __v_698: G = (__v_695 + __v_697);
+                let __v_699: G = (__v_693 + __v_698);
+                let __v_700: G = (__v_691 + __v_699);
+                let __v_701: G = (__v_689 + __v_700);
+                let __v_702: G = (__v_687 + __v_701);
+                let __v_703: G = (__v_685 + __v_702);
+                let __v_704: G = (__v_540 + __v_703);
+                let __v_705: G = G::from_u64(256);
+                let __v_706: G = (__v_705 * __v_549);
+                let __v_707: G = G::from_u64(65536);
+                let __v_708: G = (__v_707 * __v_550);
+                let __v_709: G = G::from_u64(16777216);
+                let __v_710: G = (__v_709 * __v_551);
+                let __v_711: G = G::from_u64(4294967296);
+                let __v_712: G = (__v_711 * __v_552);
+                let __v_713: G = G::from_u64(1099511627776);
+                let __v_714: G = (__v_713 * __v_553);
+                let __v_715: G = G::from_u64(281474976710656);
+                let __v_716: G = (__v_715 * __v_554);
+                let __v_717: G = G::from_u64(72057594037927936);
+                let __v_718: G = (__v_717 * __v_555);
+                let __v_719: G = (__v_716 + __v_718);
+                let __v_720: G = (__v_714 + __v_719);
+                let __v_721: G = (__v_712 + __v_720);
+                let __v_722: G = (__v_710 + __v_721);
+                let __v_723: G = (__v_708 + __v_722);
+                let __v_724: G = (__v_706 + __v_723);
+                let __v_725: G = (__v_548 + __v_724);
+                let __v_726: G = G::from_u64(0);
+                let __v_727: G = G::from_u64(0);
+                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_726, __v_727, __v_402, __v_578, __v_599, __v_620, __v_641]; 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_728: G = __r_arr[0];
+                let __v_729: G = __r_arr[1];
+                let __v_730: G = G::from_u64(0);
+                let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_405, __v_406, __v_34, __v_30, __v_62, __v_64, __v_59, __v_60, __v_57, __v_730, __v_728, __v_729, __v_578, __v_599, __v_620, __v_641, __v_662, __v_683, __v_704, __v_725]; 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 __v_731: G = __r_arr[0];
+                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_405]; 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_732: 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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_38]; 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 __v_733: G = __r_arr[0];
+                    let __v_734: G = G::from_u64(1);
+                    let __v_735: G = G::from_u64(1);
+                    let __v_736: G = { let __values: [G; 3] = [__v_734, __v_735, __v_735]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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() {
   0u64 => {
-    break '__mc_3 [__v_688];
+    break '__mc_3 [__v_736];
   },
   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_121] = { let __args: [G; IN_121] = [__v_60, __v_736]; 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_737: G = __r_arr[0];
+    break '__mc_3 [__v_737];
   },
   _ => {
     return Err(ExecError::MatchNoCase(__v_59.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_737: G = __mc_out___mc_3[0];
+                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_57, __v_737]; 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_738: G = __r_arr[0];
+                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_64, __v_738]; 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_739: G = __r_arr[0];
+                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_62, __v_739]; 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_740: G = __r_arr[0];
+                    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_556, __v_740]; 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 __v_741: G = __r_arr[0];
+                    let __v_742: G = G::from_u64(1);
+                    let __v_743: G = G::from_u64(1);
+                    let __v_744: G = { let __values: [G; 3] = [__v_742, __v_743, __v_743]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_741, __v_744]; 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_745: G = __r_arr[0];
+                    let __v_746: G = __r_arr[1];
+                    let __v_747: G = __r_arr[2];
+                    let __v_748: G = __r_arr[3];
+                    let __v_749: G = __r_arr[4];
+                    let __v_750: G = __r_arr[5];
+                    let __v_751: G = __r_arr[6];
+                    let __v_752: G = __r_arr[7];
+                    let __v_753: G = __r_arr[8];
+                    let __v_754: G = __r_arr[9];
+                    let __v_755: G = __r_arr[10];
+                    let __v_756: G = __r_arr[11];
+                    let __v_757: G = __r_arr[12];
+                    let __v_758: G = __r_arr[13];
+                    let __v_759: G = __r_arr[14];
+                    let __v_760: G = __r_arr[15];
+                    let __v_761: G = __r_arr[16];
+                    let __v_762: G = __r_arr[17];
+                    let __v_763: G = G::from_u64(256);
+                    let __v_764: G = (__v_763 * __v_746);
+                    let __v_765: G = G::from_u64(65536);
+                    let __v_766: G = (__v_765 * __v_747);
+                    let __v_767: G = G::from_u64(16777216);
+                    let __v_768: G = (__v_767 * __v_748);
+                    let __v_769: G = G::from_u64(4294967296);
+                    let __v_770: G = (__v_769 * __v_749);
+                    let __v_771: G = G::from_u64(1099511627776);
+                    let __v_772: G = (__v_771 * __v_750);
+                    let __v_773: G = G::from_u64(281474976710656);
+                    let __v_774: G = (__v_773 * __v_751);
+                    let __v_775: G = G::from_u64(72057594037927936);
+                    let __v_776: G = (__v_775 * __v_752);
+                    let __v_777: G = (__v_774 + __v_776);
+                    let __v_778: G = (__v_772 + __v_777);
+                    let __v_779: G = (__v_770 + __v_778);
+                    let __v_780: G = (__v_768 + __v_779);
+                    let __v_781: G = (__v_766 + __v_780);
+                    let __v_782: G = (__v_764 + __v_781);
+                    let __v_783: G = (__v_745 + __v_782);
+                    let __v_784: G = G::from_u64(256);
+                    let __v_785: G = (__v_784 * __v_754);
+                    let __v_786: G = G::from_u64(65536);
+                    let __v_787: G = (__v_786 * __v_755);
+                    let __v_788: G = G::from_u64(16777216);
+                    let __v_789: G = (__v_788 * __v_756);
+                    let __v_790: G = G::from_u64(4294967296);
+                    let __v_791: G = (__v_790 * __v_757);
+                    let __v_792: G = G::from_u64(1099511627776);
+                    let __v_793: G = (__v_792 * __v_758);
+                    let __v_794: G = G::from_u64(281474976710656);
+                    let __v_795: G = (__v_794 * __v_759);
+                    let __v_796: G = G::from_u64(72057594037927936);
+                    let __v_797: G = (__v_796 * __v_760);
+                    let __v_798: G = (__v_795 + __v_797);
+                    let __v_799: G = (__v_793 + __v_798);
+                    let __v_800: G = (__v_791 + __v_799);
+                    let __v_801: G = (__v_789 + __v_800);
+                    let __v_802: G = (__v_787 + __v_801);
+                    let __v_803: G = (__v_785 + __v_802);
+                    let __v_804: G = (__v_753 + __v_803);
+                    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_761, __v_38, __v_40, __v_205]; 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_805: G = __r_arr[0];
+                    let __v_806: G = __r_arr[1];
+                    let __v_807: G = G::from_u64(1);
+                    let __v_808: G = G::from_u64(1);
+                    let __v_809: G = { let __values: [G; 3] = [__v_807, __v_808, __v_808]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_46, __v_809]; 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_810: G = __r_arr[0];
+                    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_806, __v_810]; 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 __v_811: G = __r_arr[0];
+                    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_811, __v_38]; 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_812: G = __r_arr[0];
+                    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_812, __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[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_813: G = __r_arr[0];
+                    let __v_814: G = __r_arr[1];
+                    let __v_815: G = (__v_733 + __v_155);
+                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_22]; 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 __v_816: G = __r_arr[0];
+                    let __v_817: G = G::from_u64(1);
+                    if (__v_816 != __v_817) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_816.as_canonical_u64(), rhs: __v_817.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_242] = { let __args: [G; IN_242] = [__v_22]; 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 __v_818: G = __r_arr[0];
+                    let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_252]; 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_819: G = __r_arr[0];
+                    let __v_820: G = (__v_818 - __v_819);
+                    let __v_821: G = G::from_bool((__v_820 == G::ZERO));
+                    let __v_822: G = G::from_u64(1);
+                    if (__v_821 != __v_822) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_821.as_canonical_u64(), rhs: __v_822.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_241] = { let __args: [G; IN_241] = [__v_405]; 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_823: G = __r_arr[0];
+                    let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_30]; 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 __v_824: G = __r_arr[0];
+                    let __v_825: G = (__v_823 - __v_824);
+                    let __v_826: G = G::from_bool((__v_825 == G::ZERO));
+                    let __v_827: G = G::from_u64(1);
+                    if (__v_826 != __v_827) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_826.as_canonical_u64(), rhs: __v_827.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_239] = { let __args: [G; IN_239] = [__v_40]; 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 __v_828: G = __r_arr[0];
+                    let __v_829: G = (__v_828 - __v_733);
+                    let __v_830: G = G::from_bool((__v_829 == G::ZERO));
+                    let __v_831: G = G::from_u64(1);
+                    if (__v_830 != __v_831) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_830.as_canonical_u64(), rhs: __v_831.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_234] = { let __args: [G; IN_234] = [__v_44]; 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 __v_832: G = __r_arr[0];
+                    let __v_833: G = (__v_832 - __v_195);
+                    let __v_834: G = G::from_bool((__v_833 == G::ZERO));
+                    let __v_835: G = G::from_u64(1);
+                    if (__v_834 != __v_835) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_834.as_canonical_u64(), rhs: __v_835.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_234] = { let __args: [G; IN_234] = [__v_46]; 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 __v_836: G = __r_arr[0];
+                    let __v_837: G = G::from_u64(1);
+                    if (__v_836 != __v_837) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_836.as_canonical_u64(), rhs: __v_837.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 __v_838: G = G::from_u64(33);
+                    let __v_839: G = { let __a_val = __v_815.as_canonical_u64(); let __b_val = __v_838.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_840: G = G::from_u64(1);
+                    if (__v_839 != __v_840) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_839.as_canonical_u64(), rhs: __v_840.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 __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_813, __v_814, __v_44, __v_783, __v_804, __v_62, __v_64, __v_57, __v_59, __v_60, __v_24, __v_26, __v_28, __v_407, __v_406, __v_34, __v_704, __v_725, __v_732, __v_155, __v_815, __v_805, __v_38, __v_46, __v_733]; 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_841: G = __r_arr[0];
+                    break '__mc_1 [__v_841];
                   },
                 }
               },
@@ -19184,260 +25387,260 @@ 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 __v_405: G = __mc_out___mc_1[0];
+    let __v_406: G = (__v_18 + __v_19);
+    if (__v_65 != __v_406) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_406.as_canonical_u64(), msg: None });
+    }
+    let __v_407: G = G::from_u64(256);
+    let __v_408: G = (__v_407 * __v_124);
+    let __v_409: G = G::from_u64(65536);
+    let __v_410: G = (__v_409 * __v_125);
+    let __v_411: G = G::from_u64(16777216);
+    let __v_412: G = (__v_411 * __v_126);
+    let __v_413: G = (__v_410 + __v_412);
+    let __v_414: G = (__v_408 + __v_413);
+    let __v_415: G = (__v_123 + __v_414);
+    let __v_416: G = G::from_u64(256);
+    let __v_417: G = (__v_416 * __v_128);
+    let __v_418: G = G::from_u64(65536);
+    let __v_419: G = (__v_418 * __v_129);
+    let __v_420: G = G::from_u64(16777216);
+    let __v_421: G = (__v_420 * __v_130);
+    let __v_422: G = (__v_419 + __v_421);
+    let __v_423: G = (__v_417 + __v_422);
+    let __v_424: G = (__v_127 + __v_423);
+    let __v_425: G = G::from_u64(256);
+    let __v_426: G = (__v_425 * __v_132);
+    let __v_427: G = G::from_u64(65536);
+    let __v_428: G = (__v_427 * __v_133);
+    let __v_429: G = G::from_u64(16777216);
+    let __v_430: G = (__v_429 * __v_134);
+    let __v_431: G = (__v_428 + __v_430);
+    let __v_432: G = (__v_426 + __v_431);
+    let __v_433: G = (__v_131 + __v_432);
+    let __v_434: G = G::from_u64(256);
+    let __v_435: G = (__v_434 * __v_136);
+    let __v_436: G = G::from_u64(65536);
+    let __v_437: G = (__v_436 * __v_137);
+    let __v_438: G = G::from_u64(16777216);
+    let __v_439: G = (__v_438 * __v_138);
+    let __v_440: G = (__v_437 + __v_439);
+    let __v_441: G = (__v_435 + __v_440);
+    let __v_442: G = (__v_135 + __v_441);
+    let __v_443: G = G::from_u64(256);
+    let __v_444: G = (__v_443 * __v_140);
+    let __v_445: G = G::from_u64(65536);
+    let __v_446: G = (__v_445 * __v_141);
+    let __v_447: G = G::from_u64(16777216);
+    let __v_448: G = (__v_447 * __v_142);
+    let __v_449: G = (__v_446 + __v_448);
+    let __v_450: G = (__v_444 + __v_449);
+    let __v_451: G = (__v_139 + __v_450);
+    let __v_452: G = G::from_u64(256);
+    let __v_453: G = (__v_452 * __v_144);
+    let __v_454: G = G::from_u64(65536);
+    let __v_455: G = (__v_454 * __v_145);
+    let __v_456: G = G::from_u64(16777216);
+    let __v_457: G = (__v_456 * __v_146);
+    let __v_458: G = (__v_455 + __v_457);
+    let __v_459: G = (__v_453 + __v_458);
+    let __v_460: G = (__v_143 + __v_459);
+    let __v_461: G = G::from_u64(256);
+    let __v_462: G = (__v_461 * __v_148);
+    let __v_463: G = G::from_u64(65536);
+    let __v_464: G = (__v_463 * __v_149);
+    let __v_465: G = G::from_u64(16777216);
+    let __v_466: G = (__v_465 * __v_150);
+    let __v_467: G = (__v_464 + __v_466);
+    let __v_468: G = (__v_462 + __v_467);
+    let __v_469: G = (__v_147 + __v_468);
+    let __v_470: G = G::from_u64(256);
+    let __v_471: G = (__v_470 * __v_152);
+    let __v_472: G = G::from_u64(65536);
+    let __v_473: G = (__v_472 * __v_153);
+    let __v_474: G = G::from_u64(16777216);
+    let __v_475: G = (__v_474 * __v_154);
+    let __v_476: G = (__v_473 + __v_475);
+    let __v_477: G = (__v_471 + __v_476);
+    let __v_478: G = (__v_151 + __v_477);
+    if (__v_415 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_415.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
+    }
+    if (__v_424 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_424.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None });
+    }
+    if (__v_433 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_433.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None });
+    }
+    if (__v_442 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_442.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
+    }
+    if (__v_451 != __v_4) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_451.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None });
+    }
+    if (__v_460 != __v_5) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_460.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None });
+    }
+    if (__v_469 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_469.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None });
+    }
+    if (__v_478 != __v_7) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_478.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_479: G = __loaded[0];
+    let __v_480: G = __loaded[1];
+    let __v_481: G = __loaded[2];
+    let __v_482: G = G::from_u64(1);
+    let __v_483: G = G::from_u64(1);
+    if (__v_479 != __v_482) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_479.as_canonical_u64(), rhs: __v_482.as_canonical_u64(), msg: None });
+    }
+    if (__v_480 != __v_483) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_483.as_canonical_u64(), msg: None });
+    }
+    if (__v_481 != __v_483) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_481.as_canonical_u64(), rhs: __v_483.as_canonical_u64(), msg: None });
+    }
+    let __v_484: G = G::from_u64(256);
+    let __v_485: G = (__v_484 * __v_369);
+    let __v_486: G = G::from_u64(65536);
+    let __v_487: G = (__v_486 * __v_370);
+    let __v_488: G = G::from_u64(16777216);
+    let __v_489: G = (__v_488 * __v_371);
+    let __v_490: G = (__v_487 + __v_489);
+    let __v_491: G = (__v_485 + __v_490);
+    let __v_492: G = (__v_368 + __v_491);
+    let __v_493: G = G::from_u64(256);
+    let __v_494: G = (__v_493 * __v_373);
+    let __v_495: G = G::from_u64(65536);
+    let __v_496: G = (__v_495 * __v_374);
+    let __v_497: G = G::from_u64(16777216);
+    let __v_498: G = (__v_497 * __v_375);
+    let __v_499: G = (__v_496 + __v_498);
+    let __v_500: G = (__v_494 + __v_499);
+    let __v_501: G = (__v_372 + __v_500);
+    let __v_502: G = G::from_u64(256);
+    let __v_503: G = (__v_502 * __v_377);
+    let __v_504: G = G::from_u64(65536);
+    let __v_505: G = (__v_504 * __v_378);
+    let __v_506: G = G::from_u64(16777216);
+    let __v_507: G = (__v_506 * __v_379);
+    let __v_508: G = (__v_505 + __v_507);
+    let __v_509: G = (__v_503 + __v_508);
+    let __v_510: G = (__v_376 + __v_509);
+    let __v_511: G = G::from_u64(256);
+    let __v_512: G = (__v_511 * __v_381);
+    let __v_513: G = G::from_u64(65536);
+    let __v_514: G = (__v_513 * __v_382);
+    let __v_515: G = G::from_u64(16777216);
+    let __v_516: G = (__v_515 * __v_383);
+    let __v_517: G = (__v_514 + __v_516);
+    let __v_518: G = (__v_512 + __v_517);
+    let __v_519: G = (__v_380 + __v_518);
+    let __v_520: G = G::from_u64(256);
+    let __v_521: G = (__v_520 * __v_385);
+    let __v_522: G = G::from_u64(65536);
+    let __v_523: G = (__v_522 * __v_386);
+    let __v_524: G = G::from_u64(16777216);
+    let __v_525: G = (__v_524 * __v_387);
+    let __v_526: G = (__v_523 + __v_525);
+    let __v_527: G = (__v_521 + __v_526);
+    let __v_528: G = (__v_384 + __v_527);
+    let __v_529: G = G::from_u64(256);
+    let __v_530: G = (__v_529 * __v_389);
+    let __v_531: G = G::from_u64(65536);
+    let __v_532: G = (__v_531 * __v_390);
+    let __v_533: G = G::from_u64(16777216);
+    let __v_534: G = (__v_533 * __v_391);
+    let __v_535: G = (__v_532 + __v_534);
+    let __v_536: G = (__v_530 + __v_535);
+    let __v_537: G = (__v_388 + __v_536);
+    let __v_538: G = G::from_u64(256);
+    let __v_539: G = (__v_538 * __v_393);
+    let __v_540: G = G::from_u64(65536);
+    let __v_541: G = (__v_540 * __v_394);
+    let __v_542: G = G::from_u64(16777216);
+    let __v_543: G = (__v_542 * __v_395);
+    let __v_544: G = (__v_541 + __v_543);
+    let __v_545: G = (__v_539 + __v_544);
+    let __v_546: G = (__v_392 + __v_545);
+    let __v_547: G = G::from_u64(256);
+    let __v_548: G = (__v_547 * __v_397);
+    let __v_549: G = G::from_u64(65536);
+    let __v_550: G = (__v_549 * __v_398);
+    let __v_551: G = G::from_u64(16777216);
+    let __v_552: G = (__v_551 * __v_399);
+    let __v_553: G = (__v_550 + __v_552);
+    let __v_554: G = (__v_548 + __v_553);
+    let __v_555: G = (__v_396 + __v_554);
+    if (__v_492 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_492.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
+    }
+    if (__v_501 != __v_9) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_501.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None });
+    }
+    if (__v_510 != __v_10) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_510.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None });
+    }
+    if (__v_519 != __v_11) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_519.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None });
+    }
+    if (__v_528 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_528.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None });
+    }
+    if (__v_537 != __v_13) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_537.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None });
+    }
+    if (__v_546 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_546.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None });
+    }
+    if (__v_555 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_555.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_403.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_556: G = __loaded[0];
+    let __v_557: G = __loaded[1];
+    let __v_558: G = __loaded[2];
+    let __v_559: G = G::from_u64(1);
+    let __v_560: G = G::from_u64(1);
+    if (__v_556 != __v_559) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_556.as_canonical_u64(), rhs: __v_559.as_canonical_u64(), msg: None });
+    }
+    if (__v_557 != __v_560) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_557.as_canonical_u64(), rhs: __v_560.as_canonical_u64(), msg: None });
+    }
+    if (__v_558 != __v_560) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_558.as_canonical_u64(), rhs: __v_560.as_canonical_u64(), msg: None });
+    }
+    let __v_561: G = G::from_u64(1);
+    if (__v_404 != __v_561) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_404.as_canonical_u64(), rhs: __v_561.as_canonical_u64(), msg: None });
+    }
+    let __v_562: G = G::from_u64(1);
+    if (__v_405 != __v_562) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_405.as_canonical_u64(), rhs: __v_562.as_canonical_u64(), msg: None });
+    }
+    let __ret: [G; OUT_229] = [];
+    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)); };
     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_230: usize = 2;
+const IN_230: usize = 2;
+const OUT_230: usize = 1;
+fn aiur_fn_230(
+  inp: [G; IN_230],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_192], ExecError> {
+) -> Result<[G; OUT_230], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    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_237] = { let __args: [G; IN_237] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
@@ -19445,8 +25648,8 @@ fn aiur_fn_192(
     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_230] = [__v_4];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -19456,15 +25659,15 @@ 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_231: usize = 1;
+const IN_231: usize = 1;
+const OUT_231: usize = 1;
+fn aiur_fn_231(
+  inp: [G; IN_231],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_193], ExecError> {
+) -> Result<[G; OUT_231], 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 };
@@ -19474,14 +25677,14 @@ fn aiur_fn_193(
     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 __ret: [G; OUT_231] = [__v_4];
+        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)); };
         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 __ret: [G; OUT_231] = [__v_4];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -19491,19 +25694,19 @@ 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_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_194], ExecError> {
+) -> Result<[G; OUT_232], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    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 __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_1]; 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_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];
@@ -19512,8 +25715,8 @@ fn aiur_fn_194(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       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 __ret: [G; OUT_232] = [__v_4, __v_5];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -19523,15 +25726,15 @@ fn aiur_fn_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],
+const INPUT_SIZE_233: usize = 1;
+const IN_233: usize = 1;
+const OUT_233: usize = 1;
+fn aiur_fn_233(
+  inp: [G; IN_233],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_195], ExecError> {
+) -> Result<[G; OUT_233], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
@@ -19543,17 +25746,17 @@ fn aiur_fn_195(
     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 __ret: [G; OUT_233] = [__v_6];
+        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)); };
         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 __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5]; 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 __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 __ret: [G; OUT_233] = [__v_8];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -19563,15 +25766,15 @@ 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_234: usize = 1;
+const IN_234: usize = 1;
+const OUT_234: usize = 1;
+fn aiur_fn_234(
+  inp: [G; IN_234],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_196], ExecError> {
+) -> Result<[G; OUT_234], 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 };
@@ -19582,17 +25785,17 @@ fn aiur_fn_196(
     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 __ret: [G; OUT_234] = [__v_5];
+        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)); };
         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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__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 __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 __ret: [G; OUT_234] = [__v_7];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -19602,15 +25805,15 @@ fn aiur_fn_196(
   })
 }
 
-const INPUT_SIZE_197: usize = 2;
-const IN_197: usize = 2;
-const OUT_197: usize = 1;
-fn aiur_fn_197(
-  inp: [G; IN_197],
+const INPUT_SIZE_235: usize = 2;
+const IN_235: usize = 2;
+const OUT_235: usize = 1;
+fn aiur_fn_235(
+  inp: [G; IN_235],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_197], ExecError> {
+) -> Result<[G; OUT_235], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -19627,17 +25830,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_235] = [__v_1];
+        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)); };
         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_235] = { let __args: [G; IN_235] = [__v_11, __v_1]; let __cu = unconstrained; 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 { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
         let __v_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 __ret: [G; OUT_235] = [__v_14];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -19647,15 +25850,15 @@ 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_236: usize = 2;
+const IN_236: usize = 2;
+const OUT_236: usize = 1;
+fn aiur_fn_236(
+  inp: [G; IN_236],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_198], ExecError> {
+) -> Result<[G; OUT_236], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -19665,17 +25868,17 @@ fn aiur_fn_198(
     let __v_4: G = __loaded[2];
     match __v_2.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 __ret: [G; OUT_236] = [__v_1];
+        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)); };
         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_236] = { let __args: [G; IN_236] = [__v_4, __v_1]; 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 __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 __ret: [G; OUT_236] = [__v_7];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -19685,28 +25888,28 @@ fn aiur_fn_198(
   })
 }
 
-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_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_199], ExecError> {
+) -> Result<[G; OUT_237], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     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_237] = [__v_0];
+        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)); };
         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_237] = { let __args: [G; IN_237] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __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];
@@ -19714,8 +25917,8 @@ fn aiur_fn_199(
         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_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)); };
             return Ok(__ret);
           },
           _ => {
@@ -19727,15 +25930,15 @@ 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],
+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_200], ExecError> {
+) -> Result<[G; OUT_238], 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 };
@@ -19749,17 +25952,17 @@ fn aiur_fn_200(
     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)); };
+        let __ret: [G; OUT_238] = [__v_8];
+        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)); };
         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 __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_7]; 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 __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)); };
+        let __ret: [G; OUT_238] = [__v_10];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -19769,15 +25972,15 @@ fn aiur_fn_200(
   })
 }
 
-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_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_201], ExecError> {
+) -> Result<[G; OUT_239], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
@@ -19794,17 +25997,17 @@ fn aiur_fn_201(
     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 __ret: [G; OUT_239] = [__v_11];
+        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)); };
         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 __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 __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 __ret: [G; OUT_239] = [__v_13];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -19814,19 +26017,19 @@ 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_240: usize = 2;
+const IN_240: usize = 2;
+const OUT_240: usize = 4;
+fn aiur_fn_240(
+  inp: [G; IN_240],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_202], ExecError> {
+) -> Result<[G; OUT_240], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_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_245] = { let __args: [G; IN_245] = [__v_0, __v_1]; 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 __v_2: G = __r_arr[0];
     let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
@@ -19837,8 +26040,8 @@ fn aiur_fn_202(
     let __v_8: G = __loaded[5];
     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_240] = [__v_4, __v_5, __v_6, __v_7];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -19848,15 +26051,15 @@ 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_241: usize = 1;
+const IN_241: usize = 1;
+const OUT_241: usize = 1;
+fn aiur_fn_241(
+  inp: [G; IN_241],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_203], ExecError> {
+) -> Result<[G; OUT_241], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
@@ -19871,17 +26074,17 @@ fn aiur_fn_203(
     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)); };
+        let __ret: [G; OUT_241] = [__v_9];
+        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)); };
         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 __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_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_241] = [__v_11];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -19891,15 +26094,15 @@ fn aiur_fn_203(
   })
 }
 
-const INPUT_SIZE_204: usize = 1;
-const IN_204: usize = 1;
-const OUT_204: usize = 1;
-fn aiur_fn_204(
-  inp: [G; IN_204],
+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_204], ExecError> {
+) -> Result<[G; OUT_242], 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 };
@@ -19909,17 +26112,17 @@ fn aiur_fn_204(
     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)); };
+        let __ret: [G; OUT_242] = [__v_4];
+        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)); };
         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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_3]; 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 __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)); };
+        let __ret: [G; OUT_242] = [__v_6];
+        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)); };
         return Ok(__ret);
       },
       _ => {
@@ -19929,28 +26132,66 @@ fn aiur_fn_204(
   })
 }
 
-const INPUT_SIZE_205: usize = 2;
-const IN_205: usize = 2;
-const OUT_205: usize = 1;
-fn aiur_fn_205(
-  inp: [G; IN_205],
+const INPUT_SIZE_243: usize = 2;
+const IN_243: usize = 2;
+const OUT_243: usize = 8;
+fn aiur_fn_243(
+  inp: [G; IN_243],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_205], ExecError> {
+) -> Result<[G; OUT_243], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_1]; 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 __v_2: G = __r_arr[0];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    let __v_9: G = __loaded[6];
+    let __v_10: G = __loaded[7];
+    let __v_11: G = __loaded[8];
+    let __v_12: G = __loaded[9];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_243] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_244], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_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_244] = [__v_0];
+        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)); };
         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_244] = { let __args: [G; IN_244] = [__v_0, __v_3]; 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_4: G = __r_arr[0];
         let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
@@ -19959,8 +26200,8 @@ fn aiur_fn_205(
         let __v_8: G = __loaded[3];
         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_244] = [__v_8];
+            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)); };
             return Ok(__ret);
           },
           _ => {
@@ -19972,28 +26213,28 @@ 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_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_206], ExecError> {
+) -> Result<[G; OUT_245], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     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_245] = [__v_0];
+        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)); };
         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_245] = { let __args: [G; IN_245] = [__v_0, __v_3]; 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 __v_4: G = __r_arr[0];
         let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
@@ -20004,8 +26245,57 @@ fn aiur_fn_206(
         let __v_10: G = __loaded[5];
         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_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)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.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 __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_246] = [__v_0];
+        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)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_1 - __v_2);
+        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_3]; 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 __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))?; 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_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_246] = [__v_14];
+            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)); };
             return Ok(__ret);
           },
           _ => {
@@ -21059,6 +27349,206 @@ 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());
+    },
     _ => {
       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..98c48731c 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
@@ -61,13 +238,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..00b81b61b 100644
--- a/crates/kernel/src/shard.rs
+++ b/crates/kernel/src/shard.rs
@@ -311,12 +311,25 @@ 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,
+        }
       },
     }
   }
@@ -1399,18 +1412,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,7 +1463,7 @@ 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);
@@ -2931,6 +2967,27 @@ 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))));
+  }
+
   #[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..a18b189f8 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"
       }
     },
diff --git a/flake.nix b/flake.nix
index ce74d895f..a12cebf4f 100644
--- a/flake.nix
+++ b/flake.nix
@@ -31,7 +31,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";
     };
@@ -79,7 +79,7 @@
           # Pins the Rust toolchain
           rustToolchain = fenix.packages.${system}.fromToolchainFile {
             file = ./rust-toolchain.toml;
-            sha256 = "sha256-sqSWJDUxc+zaz1nBWMAJKTAGBuGWP25GCftIOlCEAtA=";
+            sha256 = "sha256-P30Tm3O7vQAE725YtDCDHGjNrSsfZO4us11UwJGZSJo=";
           };
 
           # Rust package
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 409361693..18710c090 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"
@@ -151,6 +151,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",
 ]